驱动DHT11单总线温湿度传感器的方式与内核驱动GPIO读写的方式基本无差异，都是通过对/dev目录下的设备文件进行write/read操作，不同的是DHT11的读取需要不断切换GPIO输入输出状态并不断做轮询，其运行层面是驱动层，对于系统来说，驱动层代码的实时性要求和读写优先级都要高于应用层代码，即要将更多的CPU任务时间片资源放到驱动层代码中，也就只有这样，才能对DHT11这种延时响应时间要求是微秒级的单总线器件进行正常读写。废话不多说放上DHT11的驱动源码，这份代码参考了一位开发驱动的朋友@jackeyt，修改了一些小地方：
  1. #include <linux/err.h>
  2. #include <linux/gpio.h>
  3. #include <linux/of_gpio.h>
  4. #include <linux/gpio/consumer.h>
  5. #include <linux/kernel.h>
  6. #include <linux/module.h>
  7. #include <linux/of.h>
  8. #include <linux/platform_device.h>
  9. #include <linux/property.h>
  10. #include <linux/slab.h>
  11. #include <linux/fs.h>
  12. #include <linux/types.h>
  13. #include <linux/delay.h>
  14. #include <linux/device.h>
  15. #include <asm/uaccess.h>
  17. static int dht11_major = 0;
  18. static int dht11_gpio=80;
  19. static struct class *dht11_class;//类
  20. static struct device *dht11_dev;//设备
  21. static const char* dht11_name = "dht11";
  24. typedef struct        DHT11_SENSOR_DATA
  25. {
  26.         u16 temp;//温度
  27.         u16 hum;//湿度
  28. }dht11_data;
  30. #define DHT11_DQ_High    gpio_direction_output(dht11_gpio, 1)
  31. #define DHT11_DQ_Low     gpio_direction_output(dht11_gpio, 0)
  32. #define DHT11_IO_IN                 gpio_direction_input(dht11_gpio)
  35. #define delay_us(x)                udelay(x)
  36. #define delay_ms(x)                msleep(x)
  38. static u8 DHT11_Read_DQ(void)   
  39. {
  40.         DHT11_IO_IN;
  41.         return gpio_get_value(dht11_gpio);
  42. }
  44. //复位DHT11
  45. static void DHT11_Rst(void)   
  46. {                 
  47.         DHT11_DQ_Low;
  48.         msleep (20);  //拉低至少18ms
  49.         DHT11_DQ_High; //DQ=1
  50.         delay_us (30);  //主机拉高20~40us
  51. }
  53. //等待DHT11的回应
  54. //返回1:未检测到DHT11的存在
  55. //返回0:存在
  56. static u8 DHT11_Check(void)   
  57. {   
  58.         u8 retry=0;//定义临时变量
  59.         DHT11_IO_IN;//SET INPUT
  60.         while ((DHT11_Read_DQ()==1)&&retry<100)//DHT11会拉低40~80us
  61.         {
  62.                 retry++;
  63.                 delay_us(1);
  64.         };
  65.         if(retry>=100)return 1;
  66.         else retry=0;
  67.         while ((DHT11_Read_DQ()==0)&&retry<100)//DHT11拉低后会再次拉高40~80us
  68.         {
  69.                 retry++;
  70.                 delay_us(1);
  71.         };
  72.         if(retry>=100)return 1;   
  73.         return 0;
  74. }
  76. //从DHT11读取一个位
  77. //返回值：1/0
  78. static u8 DHT11_Read_Bit(void)  
  79. {
  80.         u8 retry=0;
  81.         while((DHT11_Read_DQ()==1)&&retry<100)//等待变为低电平
  82.         {
  83.                 retry++;
  84.                 delay_us(1);
  85.         }
  86.         retry=0;
  87.         while((DHT11_Read_DQ()==0)&&retry<100)//等待变高电平
  88.         {
  89.                 retry++;
  90.                 delay_us(1);
  91.         }
  92.         delay_us(40);//等待40us
  93.         if(DHT11_Read_DQ()==1)
  94.         return 1;
  95.         else
  96.         return 0;   
  97. }
  98. //从DHT11读取一个字节
  99. //返回值：读到的数据
  100. static u8 DHT11_Read_Byte(void)   
  101. {        
  102.     u8 i,dat;
  103.     dat=0;
  104.         for (i=0;i<8;i++)
  105.         {
  106.                 dat<<=1;
  107.                 dat|=DHT11_Read_Bit();
  108.         }   
  109.         return dat;
  110. }
  112. //从DHT11读取一次数据
  113. //temp:温度值(范围:0~50°)
  114. //humi:湿度值(范围:20%~90%)
  115. //返回值：0,正常;1,读取失败
  116. static u8 DHT11_Read_Data(u16 *temp,u16 *humi)   
  117. {        
  118.         u8 buf[5];
  119.         u8 i;
  120.         DHT11_Rst();
  121.         if(DHT11_Check()==0)
  122.         {
  123.                 for(i=0;i<5;i++)//读取40位数据
  124.                 {
  125.                         buf[i]=DHT11_Read_Byte();
  126.                 }
  127.                 if((buf[0]+buf[1]+buf[2]+buf[3])==buf[4])
  128.                 {
  129.                         *humi=buf[0]<<8|buf[1];
  130.                         *temp=buf[2]<<8|buf[3];
  131.                         printk("buf=%d,%d,%d,%d,%d\n",buf[0],buf[1],buf[2],buf[3],buf[4]);
  132.                 }
  133.         }else return 1;
  134.         return 0;   
  135. }
  136. //初始化DHT11的IO口 DQ 同时检测DHT11的存在
  137. //返回1:不存在
  138. //返回0:存在     
  139. static void DHT11_Init(void)
  140. {     
  141.         DHT11_Rst();  //复位DHT11
  142.         DHT11_Check();//等待DHT11的回应
  143. }
  145. int DHT11_open(struct inode *inode, struct file *flips)
  146. {
  147.         printk("--------------%s--------------\n",__FUNCTION__);
  148.         return 0;
  149. }
  151. static ssize_t DHT11_read(struct file *file, char __user *buf,
  152.                     size_t nbytes, loff_t *ppos)
  153. {       
  154.         printk("--------------%s--------------\n",__FUNCTION__);
  155.        
  156.         dht11_data Last_dht11_data;
  158.         if(DHT11_Read_Data(&Last_dht11_data.temp,&Last_dht11_data.hum) == 0)//读取温湿度值
  159.         {
  160.                 if (raw_copy_to_user(buf,&Last_dht11_data,sizeof(Last_dht11_data)) )
  161.                 {
  162.                         return EFAULT ;
  163.                 }
  164.         }
  166. }
  168. static int DHT11_close(struct inode *inode, struct file *flip)
  169. {
  170.         printk("--------------%s--------------\n",__FUNCTION__);
  171.         return 0;
  172. }
  174. static struct file_operations dht11_fops = {
  175.         .owner = THIS_MODULE,
  176.         .read = DHT11_read,
  177.         .open = DHT11_open,
  178.         .release = DHT11_close,
  179. };
  181. static const struct of_device_id of_dht11_match[] = {
  182.         { .compatible = "dht11", },
  183.         {},
  184. };
  186. MODULE_DEVICE_TABLE(of, of_dht11_match);
  190. static int dht11_probe(struct platform_device *pdev)
  191. {
  192.         int ret;  
  193.         enum of_gpio_flags flag;//(flag == OF_GPIO_ACTIVE_LOW) ?
  195.         printk("-------%s-------------\n", __FUNCTION__);
  196.        
  197.     struct device_node *dht11_gpio_node = pdev->dev.of_node;
  198.        
  199.         //dht11_gpio = of_get_named_gpio_flags(dht11_gpio_node->child, "gpios", 0, &flag);
  201.         if (!gpio_is_valid(dht11_gpio))
  202.         {
  203.             printk("dht11-gpio: %d is invalid\n", dht11_gpio);
  204.                 return -ENODEV;
  205.     }
  206.         else
  207.                 printk("dht11-gpio: %d is valid!\n", dht11_gpio);
  208.         if (gpio_request(dht11_gpio, "dht11-gpio"))
  209.         {
  210.         printk("gpio %d request failed!\n", dht11_gpio);
  211.         gpio_free(dht11_gpio);
  212.         return -ENODEV;
  213.     }
  214.         else
  215.                 printk("gpio %d request success!\n", dht11_gpio);
  216.         //能够读到配置信息之后就可以开始创建设备节点
  217.         dht11_major = register_chrdev(0, "dht11",&dht11_fops);
  218.         if(dht11_major <0)
  219.         {
  220.                 printk(KERN_ERR "reg error!\n");
  221.                 goto err_0;               
  222.         }
  223.         else
  224.                 printk("dht11_major =%d\n",dht11_major);
  225.        
  226.         dht11_class = class_create(THIS_MODULE,"dht11_class");//creat class
  227.         if( IS_ERR(dht11_class))
  228.         {
  229.                 printk(KERN_ERR "fail create class\n");
  230.                 ret = PTR_ERR(dht11_class);
  231.                 goto err_1;
  232.         }
  233.        
  234.         //creat dht11_dev--->>/dev/dht11_dev
  235.         dht11_dev = device_create(dht11_class, NULL,MKDEV(dht11_major,0), NULL, dht11_name);
  236.         if(IS_ERR(dht11_dev))
  237.         {
  238.                 printk(KERN_ERR "fail create device!\n");
  239.                 ret = PTR_ERR(dht11_dev);
  240.                 goto err_2;               
  241.         }
  242.        
  243.         //init dht11
  244.         DHT11_Init();
  245.         printk("dht11 Initing...\n");
  246.         return 0;
  247.        
  248. err_2:
  249.                 device_destroy(dht11_class,MKDEV(dht11_major,0));
  250. err_1:
  251.                 class_destroy(dht11_class);
  252. err_0:
  253.                 unregister_chrdev(dht11_major,dht11_name);       
  254.                 return -1;
  255. }
  257. static int dht11_remove(struct platform_device *pdev)
  258. {
  259.         printk("-------%s-------------\n", __FUNCTION__);
  260.         device_destroy(dht11_class,MKDEV(dht11_major,0));
  261.         class_destroy(dht11_class);
  262.         unregister_chrdev(dht11_major,dht11_name);
  263.         return 0;
  264. }
  266. static void dht11_shutdown(struct platform_device *pdev)
  267. {
  268.         printk("-------%s-------------\n", __FUNCTION__);
  269. }
  271. static struct platform_driver dht11_driver = {
  272.         .probe                = dht11_probe,
  273.         .remove                = dht11_remove,
  274.         .shutdown        = dht11_shutdown,
  275.         .driver                = {
  276.                 .name        = "dht11_driver",
  277.                 .of_match_table = of_dht11_match,
  278.         },
  279. };
  281. module_platform_driver(dht11_driver);


首先是GPIO引脚确定的方式，我将朋友的通过设备树锁定的方式改为在驱动代码里面动态分配，通过宏定义进行指定，不在设备树里面锁定任何GPIO；然后是里面的printk打印会出现在串口终端中，不管串口终端有没有在执行别的进程；对于内核源码中的udelay() msleep() gpio_direction_output() gpio_get_value()等函数则与ARM的单片机用法基本一样，可以完美兼容，唯一的不同点就是应用层代码对/dev设备进行wirte/read的时机和方式有要求。
然后是makefile代码，这个直接套用模板即可，内核源码目录用回之前的/mnt/imx8maaxksrc：
编译完成之后，需要使用
  1. insmod dht11_drv.ko
命令进行驱动插入：
20.jpg

可以看到，DHT11驱动源码中的dht11_probe函数加入的printk打印在插入的时候就已经生效了。
然后是单独对DHT11器件进行简单读写的main函数：
这里我注意到一点，对于/dev/dht11设备，读取间隔是1秒1次，不管是在主线程（main()）中还是在新开辟的线程中，都必须要有这个间隔，不然读取会失败，一般对于DHT11这种轮询器件而言，都是有必要开启一个单独线程进行读取的，比较Linux中线程资源非常充足，而DHT11对于实时性要求又比较高。
然后我这边套用一套以前自己写的HTTP网页服务器代码，非常简单，是通过TCP方式进行GET/POST操作，简单得不能再简单那种：
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4. #include <stdint.h>
  5. #include <string.h>
  6. #include <errno.h>
  7. #include <fcntl.h>
  8. #include <time.h>
  9. #include <unistd.h>
  10. #include <string.h>
  11. #include <fcntl.h>
  12. #include <unistd.h>
  13. #include <pthread.h>
  14. #include <linux/input.h>
  15. #include <sys/mman.h>
  16. #include <sys/socket.h>
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <arpa/inet.h>
  20. #include <netinet/in.h>
  22. #define RUN  1
  23. #define STOP 0
  25. pthread_t id1,id2;
  26. int fd_socket_server,fd_socket_conn;
  27. pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
  28. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  29. char sendbuf[420],recvbuf[1000];
  30. int thread_flag=0,status=STOP;
  31. #define TEMP_PATH "/sys/class/thermal/thermal_zone0/temp"
  33. #define DHT11_PATH "/dev/dht11"
  35. typedef struct
  36. {
  37.         short temp;
  38.         short humi;
  39. }dht11_data;
  41. dht11_data dht11_data1;
  42. int fd_dht11;
  43. float dht11_temp,dht11_humi;
  46. void *Thread_CPU_Temp(void *arg)
  47. {
  48.     void *ret;
  49.     int fd,retval;
  50.     float temp=0;
  51.     char buf[30];
  52.         while(1)
  53.         {
  54.                 read( fd_dht11 , &dht11_data1 , sizeof(dht11_data1));
  55.                 if(dht11_data1.temp != 0xffff)
  56.                 {
  57.                         dht11_temp = (dht11_data1.temp>>8)*1.0 + (dht11_data1.temp&0xff)*0.1;
  58.                         dht11_humi = (dht11_data1.humi>>8)*1.0 + (dht11_data1.humi&0xff)*0.1;
  59.                 }
  60.                 sleep(1);
  61.         }
  62.     while(1)
  63.     {
  64.                 //                pthread_mutex_lock(&mut);
  65.                 //                  while(!status)
  66.                 //                  {
  67.                 //                          pthread_cond_wait(&cond, &mut);
  68.                 //                  }
  69.                 //                  pthread_mutex_unlock(&mut);
  70.         fd = open(TEMP_PATH, O_RDONLY);
  71.         if (fd<0)
  72.         {
  73.             fprintf(stderr,"无法打开thermal_zone0/temp文件\n");
  74.             return ret;
  75.         }
  76.         if (read(fd,buf,30)<0)
  77.         {
  78.             fprintf(stderr,"读取温度数据失败\n");
  79.             return ret;
  80.         }
  82.         temp = atoi(buf)/1000.0;
  83.         printf("CPU温度��?.1f\n",temp);
  84.         buf[0]=(int)temp/10%10+'0';
  85.         buf[1]=(int)temp%10+'0';
  86.         buf[2]='.';
  87.         buf[3]=(int)(temp*10)%10+'0';
  88.         buf[4]=0;
  89.         send(fd_socket_conn,buf,5,0);
  90.         sleep(1);
  91.     }
  92. }
  94. float Get_CPU_Temp()
  95. {
  96.     float temp;
  97.     char buf_cpu_temp_read[30];
  98.         int fd = open(TEMP_PATH, O_RDONLY);
  99.        
  100.     if (fd < 0)
  101.     {
  102.         printf("无法打开thermal_zone0/temp文件\n");
  103.         return 0;
  104.     }
  105.     if (read(fd,buf_cpu_temp_read,30) < 0)
  106.     {
  107.         printf("读取温度数据失败\n");
  108.         return 0;
  109.     }
  110.     return atoi(buf_cpu_temp_read)/1000.0;
  111. }
  113. void thread_resume()
  114. {
  115.         if (status == STOP)
  116.         {
  117.             pthread_mutex_lock(&mut);
  118.             status = RUN;
  119.             pthread_cond_signal(&cond);
  120.             printf("CPU温度检测线程恢复运行\n");
  121.             pthread_mutex_unlock(&mut);
  122.         }
  123.         else
  124.         {
  125.             printf("CPU温度检测线程一直在运行\n");
  126.         }
  127. }
  129. void thread_pause()
  130. {
  131.         if (status == RUN)
  132.         {
  133.                 pthread_mutex_lock(&mut);
  134.                 status = STOP;
  135.                 printf("CPU温度检测线程暂停（挂起）\n");
  136.                 pthread_mutex_unlock(&mut);
  137.         }
  138.         else
  139.         {
  140.                 printf("CPU温度检测线程一直在暂停\n");
  141.         }
  142. }
  144. char *buf_html;
  145. char a[90]={"HTTP/1.1 200 OK\nContent-Length:00075\nServer: Hatschi Server 1.0\nContent-Type: text/html\n\n"};
  146. int flag_get=0,flag_post=0,flag_keep_alive=0,flag_post_once=1,len_buf_html=0;
  148. int File_Read_Length(char* filename)
  149. {
  150.     FILE *f=fopen(filename,"rb");
  151.     if (!f)
  152.     {
  153.         printf("Can't open bin file!\n");
  154.         return 0;
  155.     }
  156.     fseek(f,0,SEEK_END);
  157.     int len = ftell(f);
  158.     fseek(f,0,SEEK_SET);
  159.     fclose(f);
  160.     return len;
  161. }
  163. void File_Read_All_Text(char* filename)
  164. {
  165.     FILE *f = fopen(filename,"r");
  166.     fseek(f,0,SEEK_END);
  167.     long len = ftell(f);
  168.     buf_html=(char*)malloc(len+1);
  169.     rewind(f);
  170.     fread(buf_html,sizeof(char),len,f);
  171.     buf_html[len] ='\n';
  172.     buf_html[len+1] ='\0';
  173. }
  175. void *Thread_Send(void *arg)
  176. {
  177.     int len,i;
  178.     float cpu_temp;
  179.     while(1)
  180.     {
  181.         if(flag_keep_alive&&flag_post_once)
  182.         {
  183.             flag_post_once=0;
  184.             if(flag_get)
  185.                 printf("收到客户端GET请求，服务器可进行一次POST操作\n");
  186.             else if(flag_post)
  187.                 printf("收到客户端POST回应，服务器可进行一次POST操作\n");
  189.             File_Read_All_Text("/home/proj/1.html");
  190.             len_buf_html=File_Read_Length("/home/proj/1.html");
  191.             printf("\n\nHTML文件长度:len_buf_html=%d\n\n",len_buf_html);
  192.             cpu_temp=Get_CPU_Temp();
  193.             printf("\n\nCPU温度:%f %.1f %.1f\n\n",cpu_temp,dht11_temp,dht11_humi);
  195.                         for(i=0;i<len_buf_html;i++)
  196.                                 if(buf_html[i]=='H'&&buf_html[i+1]=='U'&&buf_html[i+2]=='M'&&buf_html[i+3]=='1')
  197.                                         printf("\n\n----- i=%d -----\n\n",i);
  198.                        
  199.             buf_html[156]=(int)(cpu_temp)/10%10+'0';
  200.                         buf_html[157]=(int)(cpu_temp)%10+'0';
  201.             buf_html[159]=(int)(cpu_temp*10)%10+'0';
  203.             buf_html[180]=(int)(dht11_temp)/10%10+'0';
  204.             buf_html[181]=(int)(dht11_temp)%10+'0';
  205.             buf_html[183]=(int)(dht11_temp*10)%10+'0';
  207.             buf_html[204]=(int)(dht11_humi)/10%10+'0';
  208.             buf_html[205]=(int)(dht11_humi)%10+'0';
  209.             buf_html[207]=(int)(dht11_humi*10)%10+'0';
  210.                        
  211.             a[31]=len_buf_html/10000%10+'0';
  212.             a[32]=len_buf_html/1000%10+'0';
  213.             a[33]=len_buf_html/100%10+'0';
  214.             a[34]=len_buf_html/10%10+'0';
  215.             a[35]=len_buf_html%10+'0';
  216.             for(len=0;a[len]!='\0';len++)
  217.                 putchar(a[len]);
  218.             putchar('\n');
  219.             send(fd_socket_conn,a,len,0);
  220.             for(len=0;buf_html[len]!='\0';len++);
  221.             send(fd_socket_conn,buf_html,len,0);
  222.             close(fd_socket_conn);
  223.         }
  224.     }
  225. }
  227. int Char2Int(unsigned char s[])
  228. {
  229.     int result;
  230.     if('0'<=s[0]&&s[0]<='9'&&'0'<=s[1]&&s[1]<='9'&&'0'<=s[2]&&s[2]<='9'&&
  231.        '0'<=s[3]&&s[3]<='9'&&'0'<=s[4]&&s[4]<='9')
  232.         result=(s[0]-'0')*10000+(s[1]-'0')*1000+(s[2]-'0')*100+(s[3]-'0')*10+(s[4]-'0');
  233.     else if('0'<=s[0]&&s[0]<='9'&&'0'<=s[1]&&s[1]<='9'&&'0'<=s[2]&&s[2]<='9'&&
  234.             '0'<=s[3]&&s[3]<='9'&&s[4]=='\0')
  235.         result=(s[0]-'0')*1000+(s[1]-'0')*100+(s[2]-'0')*10+(s[3]-'0');
  236.     return result;
  237. }
  239. void LED_Control(int n)
  240. {
  241.     FILE *f=fopen("/sys/class/leds/status_usr0/brightness","w");
  242.     if (f==NULL)
  243.         printf("LED操作文件打开失败");
  244.     else
  245.         if(n==1)
  246.             fprintf(f,"%d",1);
  247.         else if(n==0)
  248.             fprintf(f,"%d",0);
  249.     fclose(f);
  250. }
  252. int main(int argc,char *argv[])
  253. {
  254.     int ret,locate=0;
  255.        
  256.         fd_dht11=open(DHT11_PATH,O_RDONLY);
  257.         pthread_create(&id2,NULL,Thread_CPU_Temp,NULL);
  258.        
  259.     socklen_t addrsize=sizeof(struct sockaddr);
  260.     struct sockaddr_in sockaddr_in_server,sockaddr_in_conn;
  262.     //初始化该结构体变��?
  263.     bzero(&sockaddr_in_server,sizeof(sockaddr_in_server));
  264.     sockaddr_in_server.sin_family=AF_INET;
  265.     sockaddr_in_server.sin_addr.s_addr=inet_addr(argv[1]);
  266.     sockaddr_in_server.sin_port=htons(Char2Int((unsigned char*)argv[2]));
  268.     fd_socket_server=socket(AF_INET,SOCK_STREAM,0);
  269.     if(fd_socket_server==-1)
  270.     {
  271.             printf("套接字创��?初始化失��?\n");
  272.             return -1;
  273.     }
  274.     ret=bind(fd_socket_server,(struct sockaddr *)&sockaddr_in_server,addrsize);
  275.     if(ret==-1)
  276.     {
  277.             printf("套接字绑定失��?\n");
  278.             return -1;
  279.     }
  280.     ret=listen(fd_socket_server,5);
  281.     if(ret==-1)
  282.     {
  283.             printf("服务器监听失��?\n");
  284.             return -1;
  285.     }
  287.     int i,j;
  288.     while(1)
  289.     {
  290.         fd_socket_conn=accept(fd_socket_server,(struct sockaddr *)&sockaddr_in_conn,&addrsize);
  291.         if(fd_socket_conn==-1)
  292.         {
  293.                 printf("服务器接听失��?\n");
  294.                 return -1;
  295.         }
  296.         else if(fd_socket_conn>=0)
  297.         {
  298.             printf("已有客户端成功连接服务器!\n");
  299.             ret=pthread_create(&id1,NULL,Thread_Send,NULL);
  300.             if(ret==0)
  301.                 printf("TCP发送阻塞线程创建成��?\n");
  302.         }
  303.         bzero(recvbuf,100);
  304.         recv(fd_socket_conn,recvbuf,1000,0);
  305.         printf("------\n%s\n------\n",recvbuf);
  306.         if(recvbuf[0]=='G'&&recvbuf[1]=='E'&&recvbuf[2]=='T')
  307.         {
  308.             printf("客户端浏览器发出GET请求\n");
  309.             flag_get=1;
  310.             flag_post=0;
  311.             flag_post_once=1;
  312.         }
  313.         if(recvbuf[0]=='P'&&recvbuf[1]=='O'&&recvbuf[2]=='S'&&recvbuf[3]=='T')
  314.         {
  315.             printf("客户端浏览器发出POST回应\n");
  316.             flag_get=0;
  317.             flag_post=1;
  318.             flag_post_once=1;
  319.         }
  321.         for(i=0;i<=1000;i++)
  322.         {
  323.             if(recvbuf[i]=='H'&&recvbuf[i+1]=='T'&&recvbuf[i+2]=='T'&&recvbuf[i+3]=='P'&&
  324.                recvbuf[i+4]=='/')
  325.             {
  326.                     printf("HTTP协议版本/类型��?");
  327.                     for(j=i;j<=i+7;j++)
  328.                         putchar(recvbuf[j]);
  329.                             putchar('\n');
  330.             }
  332.             if(recvbuf[i]=='H'&&recvbuf[i+1]=='o'&&recvbuf[i+2]=='s'&&recvbuf[i+3]=='t')
  333.             {
  334.                     printf("主机地址及端口号��?");
  335.                     for(j=i+6;j<=i+22;j++)
  336.                         putchar(recvbuf[j]);
  337.                             putchar('\n');
  338.             }
  339.             if(recvbuf[i]=='C'&&recvbuf[i+1]=='o'&&recvbuf[i+2]=='n'&&recvbuf[i+3]=='n'&&
  340.                recvbuf[i+4]=='e'&&recvbuf[i+5]=='c'&&recvbuf[i+6]=='t'&&recvbuf[i+7]=='i'&&
  341.                recvbuf[i+8]=='o'&&recvbuf[i+9]=='n')
  342.             {
  343.                     printf("连接方式��?");
  344.                     for(j=i+12;j<=i+21;j++)
  345.                         putchar(recvbuf[j]);
  346.                     putchar('\n');
  347.                     flag_keep_alive=1;
  348.             }
  349.             if(recvbuf[i]=='l'&&recvbuf[i+1]=='e'&&recvbuf[i+2]=='d'&&recvbuf[i+3]=='_'&&
  350.                recvbuf[i+4]=='s'&&recvbuf[i+5]=='w'&&recvbuf[i+6]=='i'&&recvbuf[i+7]=='t'&&
  351.                recvbuf[i+8]=='c'&&recvbuf[i+9]=='h'&&recvbuf[i+10]=='=')
  352.             {
  353.                 printf("检测到LED控制指令:\n");
  354.                 if(recvbuf[i+11]=='o'&&recvbuf[i+12]=='n')
  355.                 {
  356.                     printf("LED开\n");
  357.                     LED_Control(1);
  358.                 }
  359.                 else if(recvbuf[i+11]=='o'&&recvbuf[i+12]=='f'&&recvbuf[i+13]=='f')
  360.                 {
  361.                     printf("LED关\n");
  362.                     LED_Control(0);
  363.                 }
  364.             }
  365.         }
  366.     }
  370.         /*
  371.         while(1)
  372.         {
  373.             fd_socket=socket(AF_INET,SOCK_STREAM,0);
  374.             if(fd_socket==-1)
  375.             {
  376.                     printf("套接字创��?初始化失��?\n");
  377.                     return -1;
  378.             }
  379.             ret=connect(fd_socket,(struct sockaddr *)&sockaddr_in_settings,addrsize);
  380.             if(ret==0)
  381.             {
  382.                 printf("与服务器建立连接\n");
  383.                 ret=pthread_create(&id1,NULL,Thread_Send,NULL);
  384.                 if(ret==0)
  385.                     printf("TCP发送阻塞线程被创建!\n");
  386.                 break;
  387.             }
  388.         }
  389.         while(1)
  390.         {
  391.             bzero(recvbuf,100);
  392.             ret=recv(fd_socket,recvbuf,100,0);
  393.             if(ret==0)
  394.             {
  395.                 printf("与服务器失去连接\n");
  396.                 ret=pthread_cancel(id1);
  397.                 if(ret==0)
  398.                     printf("TCP发送阻塞线程被取消\n");
  399.                 break;
  400.             }
  401.             printf("服务器端发来信息��?s\n",recvbuf);
  402.         }
  403.         */
  405. }
不知道为啥使用source insight打开的话中文会乱码，不管了，编码选项只是小事，只是一些打印而已。



网页HTML源码也非常简单：
  1. <html>
  2. <head>
  3. <title>英蓓特MAAX IMX8网页实验</title>
  4. </head>
  5. <body>
  6. <p>MAAX IMX8网页服务器</p>
  7. <p>dontello1996</p>
  8. <p>方式：GET+POST</p>
  9. <p>CPU温度:  . ℃</p>
  10. <p>环境温度:  . ℃</p>
  11. <p>环境湿度:  . ％</p>
  12. <p>LED灯控制实验</p>
  13. <form method="POST">
  14. <p><select name="led_switch">
  15.   <option value ="on">开</option>
  16.   <option value ="off">关</option>
  17. </select></p>
  18. <input type="submit" value="提交">
  19. </form>
  20. </body>
  21. </html>

设备树源码dts添加一个名为dht11的设备，重新编译设备树，并插入ko文件之后，会在/dev下生成dht11文件：
  1. /{
  2. dht11
  3. {
  4. compatible = "dht11";
  5. pinctrl-names = "default";
  6. };
22.jpg


编译完成后，使用
  1. ./main 192.168.1.4 6666
运行，指定服务器IP和端口，看看效果：
每刷新一次网页，就会读取一组新的CPU温度和温湿度数据：
21.jpg
IMG_20200823_191116.jpg


DHT11的驱动ko： DHT11.zip (39.58 KB, 下载次数: 0)
热门资料
热门活动
技术文库
全部回复 0
暂无评论，快来抢沙发吧