php黑洞网 首页
资源下载

php电子书

php视频教程

php小游戏

php脚本

php项目实战

其他资源

博客 问答 程序员的那些事
写博客 注册

程序员最近都爱上了这个网站  程序员们快来瞅瞅吧！  it98k网:it98k.com

本站消息

站长简介/公众号

  出租广告位,需要合作请联系站长

+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

2024-11(2)

实战！手把手教你如何编写一个Linux驱动并写一个支持物联网的LED演示demo

发布于2021-06-07 21:35     阅读(1345)     评论(0)     点赞(2)     收藏(5)

目录

一.开发环境

二. 准备工作：

1. 创建一个项目工程目录

2. 创建输出与目标目录

3.头文件目录

4. 建立源代码src目录

5. 使用git管理你的项目

三.编写LED驱动

三.一 准备工作

三.二 init实现

三.四 exit实现

三.五 make实现

三. 六 open实现

三.七 write实现

三.八 read实现

三.九 ioctl实现

四、编写测试APP

五. 物联网

六.在make添加支持

七. 最终演示

一.开发环境

开发板：

核心板：TQ210CoreB

底板：TQ210 V4

CPU：s5pv210

内核：Linux_kernel_3.0.8

交叉编译系统环境：

操作系统：ubnutu16.04

编译器：arm-embedsky-linux-gnueabi工具链 4.4.6

所需知识点：

若你是刚入门的学生不太看得懂原理图与芯片手册，请先看下这篇文章中针对电路原理与芯片文档这块的教程：详细介绍如何读懂STM32开发板电路原理图以及芯片文档和开发手册，并编写一个测试程序：点亮一个LED灯

本文还需要对Linux设备管理器有一定的了解，否则你开发时只知道调这些函数，但不知道内核态发生了什么，所以建议大家学一下相关知识点：Linux嵌入式开发_主设备号与次设备号详解、Linux驱动开发_设备文件系统详解

本文使用GIT来管理项目，GIT方面的教程：关于Git这一篇就够了

内核开发基本知识：Linux内核开发_内核模块

针对位的高级应用：c语言位操作的高级应用

HTTP方面：

Http响应码含义

HTTP协议下GET与POST的区别

HTTP请求报头中各个字段的含义

开源字符处理类库：CharString类 拆分自自己研发的web服务器中的类库

这些知识点我都在别的文章中有详细的解释，若对单片机/嵌入式体系基础较差的同学可以看一看。

本篇教程较为类GNU/LINUX风格，从目录体系到项目管理，都会以类GNU/LINUX风格编写

即便是一个小demo我们也要用git来管理，这是为了加深大家对git的了解与认识，也为将来的工作做准备。

请大家先看完上面的知识在继续学习本篇知识。

二. 准备工作：

工欲善其事必先利其器，当我们开发一个项目工程时，需要构建好项目体系，这样便于我们后面的开发，也让我们的项目变得可维护性更高一点

1. 创建一个项目工程目录

mkdir moudul && cd moudul

2. 创建输出与目标目录

arch、output

这两个目录将用于目标文件的输出以及中间文件的输出目录。

在arch目录下在新建一个arm的目录，因为我们的板子是arm架构，所以新建一个目录用来存放arm的目标文件，这样的体系是源于Linux内核目录体系

  1. mkdir arch && mkdir arch/arm
  2. mkdir output

3.头文件目录

在建立一个头文件目录,同时在include目录下创建一个目录TQ210_LED，代表工程类型，然后在这个目录下创建两个子目录：device、app，用来存放驱动/app的头文件

  1. mkdir include
  2. mkdir include/TQ210_LED
  3. mkdir include/TQ210_LED/device
  4. mkdir include/TQ210_LED/app

4. 建立源代码src目录

目录结构与头文件目录一致

  1. mkdir src
  2. mkdir src/TQ210_LED
  3. mkdir src/TQ210_LED/device
  4. mkdir src/TQ210_LED/app

好了到此我们的工程体系已经建立完成

  1. beis@ubuntu:~/moudul$ tree
  2. .
  3. ├── arch
  4. │   └── arm
  5. ├── include
  6. │   └── TQ210_LED
  7. │       ├── app
  8. │       └── device
  9. ├── output
  10. └── src
  11.     └── TQ210_LED
  12.         ├── app
  13.         └── device

目录结构分配的非常清晰合理，当我们新增别的模块时，只需要按照这个规范在src与include下建立不同的类型目录就可以了

若别的架构只需要在arch下建立对应的架构目录即可。

目录体系完成之后我们在使用GIT来管理我们的项目

5. 使用git管理你的项目

git init

三.编写LED驱动

在src/TQ210_LED/device目录下新建一个.c文件和在include/TQ210_LED/device目录下新建一个.h文件

  1. touch src/TQ210_LED/device/TQ210_LED_device.c
  2. touch include/TQ210_LED/device/TQ210_LED_device.h

然后使用vim打开.c文件我们就可以开始编写驱动模块啦

vim src/TQ210_LED/device/TQ210_LED_device.c

现在我们打开电路原理图，这是开发步骤的必须的第一步，因为只有看原理图才知道电路的结构。

在原理图中找到LED这一块并放大

从原理图中可以得知LED1、LED2都接在GPC端口上。

 vdd表示器件内部工作电压的符号，vdd5v的意思就是至少需要5伏电压才能让此器件工作，不过这个我们一般不用关系，这个一般由PCB板设计者们已经完成了，输入源端已经设定好电阻之类的器件器件来控制电流通过，包括板子使用的电流模式。

 R开头的这样的电路符号一般都是电阻名字，1K=1000欧姆，也就是说当电压流过时它会吸收掉1000欧姆的电压。

  这是一个放大三极管，用于放大电流的，型号是S8050，符号是Q，Q1代表一号放大三极管。

从这里可以看到LED1和LED2分别接在GPC0号端口上，位为3与4

这里我教大家如何通过GPC0_4这个标识来找到芯片手册里的对应标志位

我们打开芯片手册，先看下GPIO的框架图

它由两部分组成 OFF PART（断电部分）和ALILVE PART（带电部分）

两者分别为，睡眠模式与非睡眠模式，也就是说这个GPIO框架支持睡眠模式与非睡眠模式，若进入睡眠模式则整个框架内部时钟将停止工作，等待其它中断将其唤醒，同时在睡眠模式下是能够保证其GPIO内部寄存器的值的。

它挂载在APB总线上，并且APB没有挂接到RCC这样的时钟总线上，不像STM32是挂接在这个总线上，若不先开启它则APB总线不会工作，这是STM32出于低功耗的设计。

接着我们找到GPC端口的描述                                        

 

这里建议大家在打开PDF时使用CTRL+F去搜索GPC0能快速找到对应的说明页

按照单片机的开发的经验来说，我们可以知道若想让一个GPC口工作，必须使其设置为OUTPUT模式

同时可以看到DAT寄存器的介绍

DAT说明:

当端口配置为输入端口时，对应位为引脚状态当端口配置为输出端口时，引脚状态与对应位相同当端口配置为功能引脚时，将读取未定义的值。

也就是说CON对应端口是输出时，DAT对应的就是状态值，给1即高电平，给0即低电平。

在三星s5pv210中每个GPIO口由CON和DAT组成，CON是控制状态，DAT是输入输出状态。

并且我们可以看到GPC0CON的端口地址为：0xE0200060

GPC0DAT的端口地址为：0XE0200064 相差四字节。

一个32位机器上的int的大小。

基本上硬件以及地址信息我们都知道了，那么就是正式写代码开始进行开发了。

三.一 准备工作

在你的src/device目录下新建一个.c的文件

touch src/TQ210_LED/device/TQ210_device_led.c

同时在创建头文件：

touch include/TQ210_LED/device/TQ210_device_led.c

然后使用你喜欢的编辑工具开始写代码吧！

首先在.c文件中包含基本头文件：

  1. #include <linux/module.h>
  2. #include <linux/ioport.h>
  3. #include <linux/io.h>
  4. #include <linux/platform_device.h>
  5. #include <linux/init.h>
  6. #include <linux/serial_core.h>
  7. #include <linux/serial.h>
  8. #include <asm/irq.h>
  9. #include <mach/hardware.h>
  10. #include <plat/regs-serial.h>
  11. #include <mach/regs-gpio.h>
  12. #include <asm/uaccess.h>

基本信息：

  1. //author
  2. MODULE_AUTHOR("Stephen Zhou");
  3. MODULE_LICENSE("GPL");

init与exit：

  1. static int __init led_init(void){
  2.  
  3. }
  4.  
  5. static void __exit led_exit(void){
  6.  
  7. }
  8.  
  9. module_init(led_init);
  10. module_exit(led_exit);

我们在增加一些基本信息：

这些信息用来存储针对设备处理器用的名字，这些在之前的文件系统详解中都有详细说过

先定义存放/dev下的名字，这个是给udev看的：

  1. //led one and two name
  2. #define LED_ONE_NAME "TQ210_LED_ONE"
  3. #define LED_TWO_NAME "TQ210_LED_TWO"

定义内核模块表中的名字，以及sysfs的名字，这个是给内核和sysfs文件系统看的

  1. //led name in kernel
  2. #define LED_KERNEL_NAME         "TQ210_LED"
  3. #define LED_SYSFS_CLASS_NAME    "TQ210_LED_CLASS"

led数量，这个是给我们程序自己看的

  1. //led device number max
  2. #define LED_NUMBER_MAX 2

在写几个针对位操作的函数：

  1. //set or get gpic bit value
  2. #define SET_GPIC(GPIC_ADDRESS,VALUE,OPE)                                *GPIC_ADDRESS OPE VALUE
  3. #define SET_GPIC_STATE(GPIC_ADDRESS,LED1_VALUE,LED2_VALUE,OPE)          *GPIC_ADDRESS OPE (LED1_VALUE | LED2_VALUE)
  4. #define GET_GPIC(GPIC_ADDRESS,VALUE)                                    *GPIC_ADDRESS & VALUE
  5.  
  6. //led gpic port
  7. #define LED1_GPIC_BIT(VALUE) (VALUE << 12)
  8. #define LED2_GPIC_BIT(VALUE) (VALUE << 16)
  9. #define LED1_GPIC_DAT_BIT(VALUE) (VALUE << 3)
  10. #define LED2_GPIC_DAT_BIT(VALUE) (VALUE << 4)

属性宏：

  1. //device gpic address
  2. #define GPIC0_CON_ADDRESS 0xE0200060
  3. #define GPIC0_DAT_ADDRESS 0xE0200064
  4. #define GPIC_ADDRESS_FORMAT 16
  5.  
  6. //state
  7. #define LED_STATE_ON  "ON"
  8. #define LED_STATE_OFF "OFF"

好了，接下来我们去实现init函数

三.二 init实现

在实现init函数之前我们在.c文件中申请几个全局变量，用来存储不同的属性：

存储led名字：

char LED_NAME[][256] = {{LED_ONE_NAME},{LED_TWO_NAME}};

存储con与dat地址：

  1. volatile unsigned long* GPIC0_address = NULL;
  2. volatile unsigned long* GPIC0_dat     = NULL;

存储内核fd与类（sysfs）fd：

  1. //drive struct
  2. static int                         led_kernel_fd                                 = 0;                           //kernel struct fd
  3. static struct class*               led_device_file_class                         = NULL;                        //sysfs fd
  4. static struct device*              led_device_class_son[LED_NUMBER_MAX]          = {NULL};

除此之外还需要一个结构体：

struct file_operations

这个结构体就是用来存储文件函数指针的，write、open等函数实现

为此我们先将write、open先定义出来，什么都不做，后面我们在实现：

  1. //open
  2. static int led_open(struct inode* inode,struct file* file){
  3.  
  4. }
  5.  
  6. //write
  7. static ssize_t led_write(struct file* file,const char __user* buf,size_t count,loff_t* ppos){
  8.  
  9. }
  10.  
  11. //read
  12. static ssize_t led_read(struct file* file,char __user* buf,size_t count,loff_t* ppos){
  13.  
  14. }
  15.  
  16. //ioctl
  17. static long led_ioctl(struct file* file,unsigned int cmd,unsigned long arg){
  18.  
  19. }

注意根据内核版本不同，在内核部分的write、read函数原型不同，可以根据自己开发板子使用的内核版本来查一下。

我们把fops结构体定义出来：

  1. //drive struct
  2. static struct file_operations led_drive_fops = {
  3.  
  4.                 .owner          = THIS_MODULE,
  5.                 .open           = led_open,
  6.                 .write          = led_write,
  7.                 .read           = led_read,
  8.                 .unlocked_ioctl = led_ioctl,
  9. };

里面的THIS_MODULE是一个地址，这个会在预编译期间被编译器替换为当前模块的地址，也就是说它指向当前模块。

init函数的目的：

将设备注册到内核并注册到类文件系统，将udev注册到dev dir

第一步注册到内核结构体中

注意在内核模块中我们尽量多打日志，利用printk函数，便于我们调试

因为内核态是不能用GDB这些来调试的。

  1. led_kernel_fd = register_chrdev(0,LED_KERNEL_NAME,&led_drive_fops);
  2.         if(led_kernel_fd < 0){
  3.                 printk("TQ210_LED[ERROR]: register_chrdev - %d\n",led_kernel_fd);
  4.                 return -1;
  5. }

第二步 注册到sysfs/sys/class dir，申请一个父节点

led_device_file_class = class_create(THIS_MODULE,LED_SYSFS_CLASS_NAME);

第三步注册子设备到类sysfs中，作为子节点

注意编译器是c99，我们不能在代码部分声明变量，所以在开头加一个i的定义

 int i = 0;      //for c99 
  1.  for(; i < LED_NUMBER_MAX; ++i){
  2.                 led_device_class_son[i] = device_create (led_device_file_class,NULL,MKDEV(led_kernel_fd,i),NULL,LED_NAME[i]);
  3.                 if(unlikely(IS_ERR(led_device_class_son[i]))) {
  4.                         printk("TQ210_LED[ERROR]: register son device\n");
  5.                         return -2;
  6.                 }
  7.         }
  8.

最后一步将物理地址映射到内核虚拟地址：

操作系统出于alu地址随机化保护原因，是不能直接访问物理地址的，需要先转化为虚拟地址。

  1.  GPIC0_address = (volatile unsigned long*)ioremap(GPIC0_CON_ADDRESS,GPIC_ADDRESS_FORMAT);
  2.  GPIC0_dat     = (volatile unsigned long*)ioremap(GPIC0_DAT_ADDRESS,GPIC_ADDRESS_FORMAT);

最后打印一下表示我们成功初始化init了。

  1. printk("TQ210_LED[SUCCESS]:init\n");
  2. return 0;

在实现一下exit函数：

三.四 exit实现

先释放子类节点，注意这里的释放是有顺序之分的

因为我们在注册的时候是先注册到内核-sysfs-sysfs子节点这样的一个流程。

在设备文件详解里我说过它的寻找方式，当我们open一个/dev下的文件时，先调用中断的do_sys_open,然后在调用do_filp_open，来从文件系统中获取节点，VFS中，因为/dev目录下的文件是存在于磁盘上的，但是这个文件都在VFS的文件描述结构体中又注册，因为VFS是管理磁盘的，然后在调用open_namei函数来根据name在VFS中获取指向这个文件的指针。

最后通过这个指针可以找到这个文件指向哪个open、write等，最后会发现通过它里面的文件指针找到的是sysfs，udev只负责根据class目录下的结构把文件注册到VFS的磁盘/DEV目录下。

然后sysfs里的节点指向内核中的节点，所以当我们想删除一个节点的话，如果先删除的是内核里的节点的话，你在去删除sysfs里的节点会发现出现段错误。

这个原因大概是因为找到sysfs节点时，linux会判断指向的内核指针是否有效，来确认这是否是一个正常的设备。

所以我们怎么注册的，就怎么反着来释放。

先释放子节点

  1. int i = 0;      //for c99
  2.  
  3. for(; i < LED_NUMBER_MAX; ++i){
  4.                 device_unregister(led_device_class_son[i]);
  5. }
  6.

释放父节点

class_destroy(led_device_file_class);

关闭io映射

  1. iounmap(GPIC0_address);
  2. iounmap(GPIC0_dat);

删除内核里的模块信息

 unregister_chrdev(led_kernel_fd,LED_KERNEL_NAME);

在打印一行log

 printk("TQ210_LED[SUCCESS]:exit\n");

在打印时非常建议大家在前面加上标识符，这样在输出log时使用grep能更清楚看到你的日志。

到这里你的雏形驱动已经完成了，你编译好之后在使用insmod命令安装的话就会看到/dev目录下对应的节点。

当使用sysfs注册时，sysfs会自动通知udev的。

现在开始写make，回到顶层目录下

三.五 make实现

内核模块的make写法已经在之前的linux内核模块文章中说过了

这里交叉编译的话记得修改KDIR还有CROSS_COMPILE的变量值就可以了

  1. ifneq ($(KERNELRELEASE),)
  2.         obj-m  := ./src/TQ210_LED/device/TQ210_device_led.o
  3. else
  4.         KDIR := /home/beis/TQ/opt/EmbedSky/TQ210/Kernel_3.0.8_TQ210_for_Linux_v2.4
  5. all:
  6.         $(MAKE) -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-embedsky-linux-gnueabi-
  7.         mv ./src/TQ210_LED/device/*.mod.c               ./output
  8.         mv ./src/TQ210_LED/device/*.ko                  ./arch/arm/TQ210_LED
  9. clean:
  10.         $(MAKE) -C $(KDIR) M=$(PWD) clean
  11.         rm ./output/*
  12. endif

然后你在make一下，就可以在arch/arm/TQ210_LED目录下看到你的ko文件了。

完成初步之后就需要git保存一下啦

  1. git add .
  2. git commit -m "one"

那么接下来回到驱动文件下实现open函数

三. 六 open实现

首先我们可以利用MINOR取的当前操作的子节点

 int son_id = MINOR(inode->i_rdev);

然后利用switch来对不同节点做不同的处理，这样就不用写多个驱动文件了

同一驱动类型，非常建议这么做。

  1. switch(son_id){
  2.  
  3.                         case 0: //led one
  4.           
  5.                         break;
  6.  
  7.                         case 1: //led two
  8.  
  9.                         break;
  10.  
  11.                         default:
  12.                                 printk("TQ210_LED[ERROR]: error son device number\n");
  13.                                 return -1;
  14.                         break;
  15.  
  16.                 }

首先利用我们写好的位函数，把led开启成输出模式

首先是先清空，在开启，这样方便进行位运算，从而不被其他位影响。

  1. case 0: //led one
  2.         SET_GPIC(GPIC0_address,~LED1_GPIC_BIT(0xf),&=);         //clear
  3.         SET_GPIC(GPIC0_address,LED1_GPIC_BIT(0x1),|=);          //output
  4. break;
  5.  
  6. case 1: //led two
  7.         SET_GPIC(GPIC0_address,~LED2_GPIC_BIT(0xf),&=);         //clear
  8.         SET_GPIC(GPIC0_address,LED2_GPIC_BIT(0x1),|=);          //output
  9. break;

针对初学者，可能对位还不是特别懂，这里我给大家拆一下，详细说一下这个步骤

 把宏展开给大家看下，以LED1举例

*GPIC0_address &= ~((0xf<<(12));

上面原理图说过，CON3[15:12]是设置模式的，0xf的二进制是1111，左移12位是1111000000000000，然后在与原位做与运算，与运算特点：两位同时为1则为1，不相同则为0

然后这里取反就是0000111111111111，与CON3做与运算：

假设CON3是1011000000001000

1011000000001000

——————————

00001111111111110

——————————

0000000000001000

可以看到非常巧妙的利用与特点，没有修改其它位把我们想要设置的位给清空了。

第二个也与之一样，在你对这些含糊不清的时候，请拿起笔来自己运算，让自己清楚才是真正明白了。

*GPIC0_address |= ((0x1<<(12));

左移12位：0001000000000000 ，或运算的特点：当一个bit位为1，则为1，所以不用做取反运算了。

0000000000001000

——————————

0001000000000000

——————————

0001000000001000

也在没有修改其它位的情况下完成了。

open实现完整代码：

  1. static int led_open(struct inode* inode,struct file* file){
  2.  
  3.                 /* open device and init */
  4.  
  5.                 //get son device number
  6.                 int son_id = MINOR(inode->i_rdev);
  7.  
  8.                 switch(son_id){
  9.  
  10.                         case 0: //led one
  11.                                 SET_GPIC(GPIC0_address,~LED1_GPIC_BIT(0xf),&=);         //clear
  12.                                 SET_GPIC(GPIC0_address,LED1_GPIC_BIT(0x1),|=);          //output
  13.                         break;
  14.  
  15.                         case 1: //led two
  16.                                 SET_GPIC(GPIC0_address,~LED2_GPIC_BIT(0xf),&=);         //clear
  17.                                 SET_GPIC(GPIC0_address,LED2_GPIC_BIT(0x1),|=);          //output
  18.                         break;
  19.  
  20.                         default:
  21.                                 printk("TQ210_LED[ERROR]: error son device number\n");
  22.                                 return -1;
  23.                         break;
  24.  
  25.                 }
  26.  
  27.                 printk("TQ210_LED[SUCCESS]:open\n");
  28.                 return 0;
  29. }

三.七 write实现

获取子节点

 int son_id = MINOR(file->f_dentry->d_inode->i_rdev);

这里我们利用一个函数从用户态往内核态拿一下参数，记得失败打log

  1. char val = 0;
  2. if(copy_from_user(&val,buf,count)){ printk("TQ210_LED[ERROR]:get user variable\n"); return -1; }

然后实现：

就是判断写入的是1则亮，0则灭，位运算在open已经仔细说过了，这里就不展开说了。

我们这里的操作要对dat寄存器，上面开头也说过了。

  1. switch(son_id){
  2.  
  3.                         case 0: //led one
  4.                                 if(val == 1){ SET_GPIC_STATE(GPIC0_dat,LED1_GPIC_DAT_BIT(1),LED2_GPIC_DAT_BIT((GET_GPIC(GPIC0_dat,LED2_GPIC_DAT_BIT(1)))),|=); }else{ SET_GPIC_STATE(GPIC0_dat,~LED1_GPIC_DAT_BIT(1),(GET_GPIC(GPIC0_dat,0)),&=); }
  5.                                 printk("TQ210_LED[MSG]:led one\n");
  6.                         break;
  7.  
  8.                         case 1: //led two
  9.                                 if(val == 1){ SET_GPIC_STATE(GPIC0_dat,LED2_GPIC_DAT_BIT(1),LED1_GPIC_DAT_BIT(GET_GPIC(GPIC0_dat,LED1_GPIC_DAT_BIT(1))),|=); }else{ SET_GPIC_STATE(GPIC0_dat,~LED2_GPIC_DAT_BIT(1),(GET_GPIC(GPIC0_dat,0)),&=); }
  10.                                 printk("TQ210_LED[MSG]:led two\n");
  11.                         break;
  12.  
  13.                         default:
  14.                                 printk("TQ210[ERROR]:can't write device number\n");
  15.                         break;
  16.  
  17. }

最后打印一下：

  1.  printk("TQ210_LED[SUCCESS]:write\n");
  2.  return 0;

完整实现：

  1. static ssize_t led_write(struct file* file,const char __user* buf,size_t count,loff_t* ppos){
  2.  
  3.                 //write device
  4.  
  5.                 //get son device number
  6.                 int son_id = MINOR(file->f_dentry->d_inode->i_rdev);
  7.  
  8.                 //get user variable to kernel variablei
  9.                 char val = 0;
  10.                 if(copy_from_user(&val,buf,count)){ printk("TQ210_LED[ERROR]:get user variable\n"); return -1; }
  11.  
  12.                 switch(son_id){
  13.  
  14.                         case 0: //led one
  15.                                 if(val == 1){ SET_GPIC_STATE(GPIC0_dat,LED1_GPIC_DAT_BIT(1),LED2_GPIC_DAT_BIT((GET_GPIC(GPIC0_dat,LED2_GPIC_DAT_BIT(1)))),|=); }else{ SET_GPIC_STATE(GPIC0_dat,~LED1_GPIC_DAT_BIT(1),(GET_GPIC(GPIC0_dat,0)),&=); }
  16.                                 printk("TQ210_LED[MSG]:led one\n");
  17.                         break;
  18.  
  19.                         case 1: //led two
  20.                                 if(val == 1){ SET_GPIC_STATE(GPIC0_dat,LED2_GPIC_DAT_BIT(1),LED1_GPIC_DAT_BIT(GET_GPIC(GPIC0_dat,LED1_GPIC_DAT_BIT(1))),|=); }else{ SET_GPIC_STATE(GPIC0_dat,~LED2_GPIC_DAT_BIT(1),(GET_GPIC(GPIC0_dat,0)),&=); }
  21.                                 printk("TQ210_LED[MSG]:led two\n");
  22.                         break;
  23.  
  24.                         default:
  25.                                 printk("TQ210[ERROR]:can't write device number\n");
  26.                         break;
  27.  
  28.                 }
  29.  
  30.                 printk("TQ210_LED[SUCCESS]:write\n");
  31.                 return 0;
  32.  
  33. }

三.八 read实现

read实现也很简单，就是利用位运算去读位的值，唯一用到的就是用户态向内核态传递参数的函数：copy_to_user

完整代码：

  1. static ssize_t led_read(struct file* file,char __user* buf,size_t count,loff_t* ppos){
  2.  
  3.                 //read led state
  4.  
  5.                 int son_id = MINOR(file->f_dentry->d_inode->i_rdev);
  6.  
  7.                 int BIT = 0;
  8.                 char on[2]  = LED_STATE_ON;
  9.                 char off[3] = LED_STATE_OFF;
  10.                 switch(son_id){
  11.  
  12.                         case 0:
  13.                                 BIT = GET_GPIC(GPIC0_dat,LED1_GPIC_DAT_BIT(1));
  14.                                 if(BIT){
  15.  
  16.                                         if(copy_to_user((char*)buf,&on,sizeof(on))) return -EFAULT;
  17.  
  18.                                 }else{
  19.                                         if(copy_to_user((char*)buf,&off,sizeof(off))) return -EFAULT;
  20.                                 }
  21.                         break;
  22.  
  23.                         case 1:
  24.                                 BIT = GET_GPIC(GPIC0_dat,LED2_GPIC_DAT_BIT(1));
  25.                                 if(BIT){
  26.  
  27.                                         if(copy_to_user((char*)buf,&on,sizeof(on))) return -EFAULT;
  28.                                         return 2;
  29.  
  30.                                 }else{
  31.                                         if(copy_to_user((char*)buf,&off,sizeof(off))) return -EFAULT;
  32.                                         return 3;
  33.                                 }
  34.                         break;
  35.  
  36.                         default:
  37.                                 printk("TQ210[ERROR]:can't write device number\n");
  38.                                 return -1;
  39.                         break;
  40.  
  41.                 }
  42.  
  43.                 printk("TQ210_LED[SUCCESS]:read\n");
  44.                 return 0;
  45. }

三.九 ioctl实现

ioctl的实现的话，linux是有要求的，ioctl思想是利用参数来获取对应属性，实现对应功能。

linux内核是利用命令码实现这些，开发者利用switch case来对不同的命令码进行不同的实现

在内核里一个命令码是这样的：

  1. ________________________________________
  2.  
  3. | 设备类型  | 序列号 |  方向 | 数据尺寸  |
  4.  
  5. |----------|--------|------|--------     |
  6.  
  7. | 8 bit　　 |  8 bit   | 2 bit |8~14 bit |
  8.  
  9. |----------|--------|------|------------ |

linux内核也提供了一些实现宏定义

  1. //nr为序号，datatype为数据类型,如int
  2. _IO(type, nr ) //没有参数的命令
  3. _IOR(type, nr, datatype) //从驱动中读数据
  4. _IOW(type, nr, datatype) //写数据到驱动
  5. _IOWR(type,nr, datatype) //双向传送

例子：

  1. #define MEM_IOC_MAGIC 'm' //定义类型
  2. #define MEM_IOCSET _IOW(MEM_IOC_MAGIC,0,int)
  3. #define MEM_IOCGQSET _IOR(MEM_IOC_MAGIC, 1, int)

linux也提供了一些判断参数是否有效的宏函数

  1. _IOC_NR()    读取基数域值 (bit0~ bit7)
  2. _IOC_TYPE    读取魔数域值 (bit8 ~ bit15)
  3. _IOC_SIZE    读取数据大小域值 (bit16 ~ bit29)
  4. _IOC_DIR     获取读写属性域值 (bit30 ~ bit31)

我的定义：

  1. //ioctl
  2. #define MEMDEV_IOC_MAGIC  's'
  3. #define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC, 1)
  4. #define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)
  5. #define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)
  6. #define MEMDEV_IOC_MAXNR  3

依旧取子节点

  1. int par = 0;
  2. int son_id = MINOR(file->f_dentry->d_inode->i_rdev);

判断类型是否有效：

  1.  if(_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC)
  2.                         return -EINVAL;

判断参数是否有效

  1.  if(_IOC_NR(cmd) > MEMDEV_IOC_MAXNR)
  2.                         return -EINVAL;

在判断读写属性是否有效

  1.  if (_IOC_DIR(cmd) & _IOC_READ){ if(access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd))){ return -EFAULT; } }
  2.                 else if(_IOC_DIR(cmd) & _IOC_WRITE) { if (access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd))){ return -EFAULT; } }

这里利用了一个access_ok是一个宏，用来判断参数的读写是否有效。

接下来就是具体实现啦

只需要判断cmd的属性就可以了。

  1.  switch(son_id){
  2.  
  3.                         case 0:
  4.                                 switch(cmd){
  5.  
  6.                                         case MEMDEV_IOCPRINT:   //Print information
  7.                                                 printk("TQ210_LED1 demo to stephen zhou\n");
  8.                                         break;
  9.  
  10.                                         case MEMDEV_IOCGETDATA: //Get parameters
  11.                                                 return __put_user(par,(int*) arg);
  12.                                         break;
  13.  
  14.                                         case MEMDEV_IOCSETDATA: //Set parameters
  15.                                                 return __get_user(par,(int*) arg);
  16.                                         break;
  17.  
  18.                                         default:
  19.                                                 return -EINVAL;
  20.                                         break;
  21.                                 }
  22.                         break;
  23.  
  24.                         case 1:
  25.                                 switch(cmd){
  26.  
  27.                                         case MEMDEV_IOCPRINT:   //Print information
  28.                                                 printk("TQ210_LED2 demo to stephen zhou\n");
  29.                                         break;
  30.  
  31.                                         case MEMDEV_IOCGETDATA: //Get parameters
  32.                                                 return __put_user(par,(int*) arg);
  33.                                         break;
  34.  
  35.                                         case MEMDEV_IOCSETDATA: //Set parameters
  36.                                                 return __get_user(par,(int*) arg);
  37.                                         break;
  38.  
  39.                                         default:
  40.                                                 return -EINVAL;
  41.                                         break;
  42.                                 }
  43.                         break;
  44. }

最后别忘记打印：

  1.  printk("TQ210_LED[SUCCESS]:ioctl\n");
  2.  return 0;

完整代码：

  1. static long led_ioctl(struct file* file,unsigned int cmd,unsigned long arg){
  2.  
  3.                 int par = 0;
  4.                 //get son id    
  5.                 int son_id = MINOR(file->f_dentry->d_inode->i_rdev);
  6.  
  7.                 //cmd su or err
  8.                 if(_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC)
  9.                         return -EINVAL;
  10.                 if(_IOC_NR(cmd) > MEMDEV_IOC_MAXNR)
  11.                         return -EINVAL;
  12.                 if (_IOC_DIR(cmd) & _IOC_READ){ if(access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd))){ return -EFAULT; } }
  13.                 else if(_IOC_DIR(cmd) & _IOC_WRITE) { if (access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd))){ return -EFAULT; } }
  14.  
  15.                 switch(son_id){
  16.  
  17.                         case 0:
  18.                                 switch(cmd){
  19.  
  20.                                         case MEMDEV_IOCPRINT:   //Print information
  21.                                                 printk("TQ210_LED1 demo to stephen zhou\n");
  22.                                         break;
  23.  
  24.                                         case MEMDEV_IOCGETDATA: //Get parameters
  25.                                                 return __put_user(par,(int*) arg);
  26.                                         break;
  27.  
  28.                                         case MEMDEV_IOCSETDATA: //Set parameters
  29.                                                 return __get_user(par,(int*) arg);
  30.                                         break;
  31.  
  32.                                         default:
  33.                                                 return -EINVAL;
  34.                                         break;
  35.                                 }
  36.                         break;
  37.  
  38.                         case 1:
  39.                                 switch(cmd){
  40.  
  41.                                         case MEMDEV_IOCPRINT:   //Print information
  42.                                                 printk("TQ210_LED2 demo to stephen zhou\n");
  43.                                         break;
  44.  
  45.                                         case MEMDEV_IOCGETDATA: //Get parameters
  46.                                                 return __put_user(par,(int*) arg);
  47.                                         break;
  48.  
  49.                                         case MEMDEV_IOCSETDATA: //Set parameters
  50.                                                 return __get_user(par,(int*) arg);
  51.                                         break;
  52.  
  53.                                         default:
  54.                                                 return -EINVAL;
  55.                                         break;
  56.                                 }
  57.                         break;
  58.                 }
  59.  
  60.                 printk("TQ210_LED[SUCCESS]:ioctl\n");
  61.                 return 0;
  62. }

好了，这里open、write、read、ioctl都已经实现啦，那么我们在写一个简单的app测试一下吧

四、编写测试APP

这里我写了一个闪烁的app代码

在src/app目录下新建一个TQ210_app_led.c的文件，用于用户态的程序

包含基本头文件

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <sys/ioctl.h>
  8. #include <stdlib.h>
  9. #include "../../../include/TQ210_LED/device/TQ210_device_led.h"

这里我写了一个基本的打印函数

  1. void print(char* led1_state,char* led2_state){
  2.         system("clear");
  3.         printf("/*****************************************************************************\n");
  4.         printf("*                                                                            *\n");
  5.         printf("*  TQ210 LED的demo演示                                                       *\n");
  6.         printf("*  Copyright (C) 2021 StephenZhou                                            *\n");
  7.         printf("*                                                                            *\n");
  8.         printf("*----------------------------------------------------------------------------*\n");
  9.         printf("*  Device         : State                                                    *\n");
  10.         printf("*----------------------------------------------------------------------------*\n");
  11.         if(strcmp(led1_state,"ON") == 0){ printf("*  TQ210_LED_ONE  : ON                                                             *\n"); }
  12.         else{ printf("*  TQ210_LED_ONE  : OFF                                                        *\n"); }
  13.         printf("*----------------------------------------------------------------------------*\n");
  14.         if(strcmp(led2_state,"ON") == 0){ printf("*  TQ210_LED_TWO  : ON                                                             *\n"); }
  15.         else{ printf("*  TQ210_LED_TWO  : OFF                                                        *\n"); }
  16.         printf("*----------------------------------------------------------------------------*\n");
  17.         printf("*  Change History :                                                          *\n");
  18.         printf("*  <Date>     | <Version> | <Author>       | <Description>                   *\n");
  19.         printf("*----------------------------------------------------------------------------*\n");
  20.         printf("*  2020/5/25 | 1.0.0.0   | StephenZhou      | LED Demo                       *\n");
  21.         printf("*----------------------------------------------------------------------------*\n");
  22.         printf("*                                                                            *\n");
  23.         printf("*****************************************************************************/\n");
  24.  
  25. }

第一步就是声明基本变量，然后就按照open、write的方式写就可以了，注释我写的非常清楚

就是先open打开，然后read读取状态，把状态打印出来，并且调用ioctl来打印基本信息，在使用write写入状态。

  1. int main(int argc,char **argv){
  2.  
  3.         /* Two LEDs flash each other and print the status */
  4.         int cmd = 0,arg = 0,val = 0;
  5.         char led1_state[4] = {0},led2_state[4] = {0};
  6.         //1. open udev device
  7.         int led_fd1 = open(LED_DEV_ONE_NAME,O_RDWR);
  8.         int led_fd2 = open(LED_DEV_TWO_NAME,O_RDWR);
  9.         if(led_fd1 == -1 || led_fd2 == -1){
  10.                 printf("error:can't open led device\n");
  11.                 return -1;
  12.         }
  13.  
  14.         //2. print msg to kernel ioctl
  15.         cmd = MEMDEV_IOCPRINT;
  16.         if(ioctl(led_fd1,cmd,&arg) == -1) { printf("error:can't ioctl for led1\n"); return -1; }
  17.         cmd = MEMDEV_IOCPRINT;
  18.         if(ioctl(led_fd2,cmd,&arg) == -1) { printf("error:can't ioctl for led2\n"); return -1; }
  19.  
  20.         //3. wink
  21.         while(1){
  22.  
  23.                 //led one wink led two close
  24.                 val = 1;
  25.                 if(write(led_fd1,&val,sizeof(val)) == -1){ printf("error:can't write for led1\n"); return -1; }
  26.                 val = 0;
  27.                 if(write(led_fd2,&val,sizeof(val)) == -1){ printf("error:can't write for led2\n"); return -1; }
  28.  
  29.                 //clear string
  30.                 memset(led1_state,0,sizeof(led1_state));
  31.                 memset(led2_state,0,sizeof(led2_state));
  32.  
  33.                 //read led state
  34.                 if(read(led_fd1,led1_state,sizeof(led1_state)) == -1){ printf("error:cant't read for led1\n"); return -1; }
  35.                 if(read(led_fd2,led2_state,sizeof(led2_state)) == -1){ printf("error:cant't read for led2\n"); return -1; }
  36.                 print(led1_state,led2_state);
  37.  
  38.                 sleep(3);
  39.  
  40.                 //led two wink led one close
  41.                 val = 1;
  42.                 if(write(led_fd2,&val,sizeof(val)) == -1){ printf("error:can't write for led1\n"); return -1; }
  43.                 val = 0;
  44.                 if(write(led_fd1,&val,sizeof(val)) == -1){ printf("error:can't write for led2\n"); return -1; }
  45.  
  46.                 //clear string
  47.                 memset(led1_state,0,sizeof(led1_state));
  48.                 memset(led2_state,0,sizeof(led2_state));
  49.  
  50.                 //read led state
  51.                 if(read(led_fd1,led1_state,sizeof(led1_state)) == -1){ printf("error:cant't read for led1\n"); return -1; }
  52.                 if(read(led_fd2,led2_state,sizeof(led2_state)) == -1){ printf("error:cant't read for led2\n"); return -1; }
  53.                 print(led1_state,led2_state);
  54.  
  55.                 sleep(3);
  56.  
  57.         }
  58.  
  59.         return 0;
  60. }

我们在把app文件添加到make里，用交叉编译器

以下是我修改后的make

我使用了一些mv命令来把生成的临时文件以及目标文件都放到固定目录中。

  1. ifneq ($(KERNELRELEASE),)
  2.         obj-m  := ./src/TQ210_LED/device/TQ210_device_led.o
  3. else
  4.         KDIR := /home/beis/TQ/opt/EmbedSky/TQ210/Kernel_3.0.8_TQ210_for_Linux_v2.4
  5. all:
  6.         $(MAKE) -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-embedsky-linux-gnueabi-
  7.         arm-embedsky-linux-gnueabi-gcc ./src/TQ210_LED/app/TQ210_app_led.c -o TQ210_app_led
  8.         mv ./src/TQ210_LED/device/*.o                   ./output
  9.         mv *.symvers                                    ./output
  10.         mv *.order                                      ./output
  11.         mv ./src/TQ210_LED/device/*.mod.c               ./output
  12.         mv ./src/TQ210_LED/device/*.ko                  ./arch/arm/TQ210_LED
  13.         mv TQ210_app_led                                ./arch/arm/TQ210_LED
  14. clean:
  15.         $(MAKE) -C $(KDIR) M=$(PWD) clean
  16.         rm ./output/*
  17.         rm ./arch/arm/TQ210_LED/*
  18.         rm ./arch/arm/network/*
  19. endif

这个时候你在make一下就能在arch/arm/TQ210_LED目录下看到app和.ko文件了。

  1. beis@ubuntu:~/moudul/arch/arm/TQ210_LED$ tree
  2. .
  3. ├── TQ210_app_led
  4. └── TQ210_device_led.ko
  5.  
  6. 0 directories, 2 files

最后别忘记git一下

  1. git add .
  2. git commit -m "two"

到这一步基本一个demo就已经写完了，那么接下里我们让它物联网

写一个server服务器来控制它

以下代码是我以前写过web ui的方法实现的。

五. 物联网

在src目录下新建一个network目录，在此目录新建一个server.c文件，同理include目录也是一样

这部分如果你对http开发以及网站开发没有开发经验的话可以跳过，这里我是自己写的服务器是为了让大家更清楚了解物联网原理，可以去看下我关于http协议的讲解，以及我开源的http解析代码

  1. mkdir src/network
  2. touch src/network/server.c
  3. mkdir include/network
  4. touch include/network/server.h

我们在写一个html用来展示前端，其就post的提交

代码很简单，存放在src/network目录下

先在.h文件里把协议以及头文件定义出来

  1. #include <stdio.h>
  2. #include <strings.h>
  3. #include <unistd.h>
  4. #include <sys/stat.h>
  5. #include <fcntl.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9. #include <arpa/inet.h>
  10. #include <string.h>
  11. #include "../../include/TQ210_LED/device/TQ210_device_led.h"
  12.  
  13. //server config
  14. #define PORT                    8081
  15. #define BACKLOG                 10
  16.  
  17. //http
  18. #define STATE_OK                "HTTP/1.0 200 OK\r\n"
  19. #define SERVER_TYPE             "Server: DWBServer\r\nContent-Type: text/html;charset=utf-8\r\n\r\n"
  20.  
  21. //file
  22. #define INDEX_NAME              "./index.html"
  23.  
  24. //http ops
  25. #define STATE_GET_INDEX         1
  26. #define STATE_BUTTON_FOO        2
  27. #define STATE_200               3
  28.  
  29. //led
  30. #define LED_1                   1
  31. #define LED_2                   2
  32. #define LED_UP                  3
  33. #define LED_DOWN                4

思路就是post提交给服务器，服务器拿到post数据然后判断数据信息来执行对应的功能

这里使用了form的表格实现了这一功能

  1. <html>
  2. <body>
  3. <form action = "" method = "post">
  4.                  <button name="foo" value="LED1_Light">LED1_点亮</button>
  5. </form>
  6. <form action = "" method = "post">
  7.        <button name="foo" value="LED1_Ext">LED1_熄灯</button>
  8. </form>
  9. <form action = "" method = "post">
  10.                  <button name="foo" value="LED2_Light">LED2_点亮</button>
  11. </form>
  12. <form action = "" method = "post">
  13.        <button name="foo" value="LED2_Ext">LED2_熄灯</button>
  14. </form>
  15. </body>
  16. </html>

server.c部分

首先包含头文件：

#include "../../include/network/server.h"

在写一个解析http协议的head代码：

这一部分是用来获取报文头的，便于服务器判断请求参数是什么

  1. int GetHead(char* buff,char* t){
  2.  
  3.         if(buff == NULL || t == NULL){
  4.                 return -1;
  5.         }
  6.         int str_len = strlen(buff);
  7.         int i = 0;
  8.         for(; i<str_len ;++i){
  9.  
  10.                 if(buff[i] == '\r'){
  11.                         break;
  12.                 }
  13.  
  14.                 t[i] = buff[i];
  15.  
  16.         }
  17.  
  18.         return 0;
  19.  
  20. }

在写一个函数用来获取报文尾部，因为post提交的话文本会在报文体的尾部

  1. int GetEnd(char* buff,char* t){
  2.         if(buff == NULL || t == NULL){
  3.                 return -1;
  4.         }
  5.  
  6.         int i = strlen(buff);
  7.         int count = 0;
  8.         int d = 0;
  9.         int y = 0;
  10.         for(;i>0;--i){
  11.                 if(buff[i] == '\n'){
  12.                         break;
  13.                 }
  14.                 ++count;
  15.         }
  16.  
  17.         d = strlen(buff) - count+1;
  18.         for(;buff[d] != '\0';++d){
  19.                 t[y++] = buff[d];
  20.  
  21.         }
  22.  
  23.         return 0;
  24. }

然后在写一个获取HTTP状态的函数，这一部分主要利用解析到的文本头来判断http客户端执行了什么操作，然后返回给我们，便于我们做对应的操作

  1. int GET_HTTP_STATE(char* buff){
  2.         
  3.         if(buff == NULL){  
  4.                 return 0;
  5.         }
  6.  
  7.         char Head[256] = {0};
  8.         GetHead(buff,Head);
  9.         if(Head == NULL){ return 0; }
  10.         
  11.         if(strcmp(Head,"GET / HTTP/1.1") == 0){
  12.                 
  13.                 return STATE_GET_INDEX;
  14.     
  15.         }
  16.     
  17.         char ff[256] = {0};
  18.         if(strcmp(Head,"POST / HTTP/1.1") == 0){
  19.                           
  20.                 return STATE_BUTTON_FOO;
  21.  
  22.         }
  23.  
  24.         return STATE_200;
  25.  
  26. }

然后就是led操作的函数，这个就不用多说了，非常简单

  1. int Led_Ops(int LED_INDEX,int STATE){
  2.  
  3.         int fd  = 0;
  4.         int val = 0;
  5.  
  6.         if(LED_INDEX == LED_1){
  7.  
  8.                 fd = open(LED_DEV_ONE_NAME,O_RDWR);
  9.                 if(fd == -1) { return -1; }
  10.         }
  11.         
  12.         if(LED_INDEX == LED_2){
  13.                 fd = open(LED_DEV_TWO_NAME,O_RDWR);
  14.                 if(fd == -1) { return -1; }
  15.         }
  16.  
  17.         if(STATE == LED_UP){
  18.                 val = 1;
  19.                 write(fd,&val,sizeof(val));
  20.         }
  21.  
  22.         if(STATE == LED_DOWN){
  23.                 val = 0;
  24.                 write(fd,&val,sizeof(val));
  25.         }
  26.  
  27.         close(fd);
  28.  
  29. }

最后就是exec的事件函数，根据返回的状态执行对应的操作，最后也要给http客户端进行反馈，200告诉它我们完成了工作，其次post提交之后我们也要返回页面，因为http客户端会显示服务器返回的数据。

  1. int Http_Exec(int state,int fd,char* buff){
  2.  
  3.         char rt[2*1024] = {0};
  4.         if(state == STATE_GET_INDEX){
  5.                 strcat(rt,STATE_OK);
  6.                 strcat(rt,SERVER_TYPE);
  7.                 strcat(rt,index_body);
  8.                 send(fd,rt,strlen(rt),0);
  9.         }
  10.  
  11.         if(state == STATE_BUTTON_FOO){
  12.                 char fun[256] = {0};
  13.                 GetEnd(buff,fun);
  14.                 strcat(rt,STATE_OK);
  15.                 strcat(rt,SERVER_TYPE);
  16.                 strcat(rt,index_body);
  17.                 send(fd,rt,strlen(rt),0);
  18.                 if(strcmp(fun,"foo=LED1_Light") == 0){
  19.                         Led_Ops(LED_1,LED_UP);
  20.                 }
  21.                 if(strcmp(fun,"foo=LED1_Ext") == 0){
  22.                         Led_Ops(LED_1,LED_DOWN);
  23.                 }
  24.                 if(strcmp(fun,"foo=LED2_Light") == 0){
  25.                         Led_Ops(LED_2,LED_UP);
  26.                 }
  27.                 if(strcmp(fun,"foo=LED2_Ext") == 0){
  28.                         Led_Ops(LED_2,LED_DOWN);
  29.                 }
  30.  
  31.         }
  32.  
  33.         if(state == STATE_200){
  34.                 strcat(rt,STATE_OK);
  35.                 strcat(rt,SERVER_TYPE);
  36.                 send(fd,rt,strlen(rt),0);
  37.         }
  38.  
  39.         return 0;
  40. }

然后就是main函数

先初始化tcp，这里我写的不是多线程，是单线程的，也就是说同一时间只能有一个http客户端响应。

  1.  int listenfd, connectfd;
  2.         struct sockaddr_in server, client;
  3.         socklen_t addrlen;
  4.  
  5.         if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
  6.                 perror("[SERVER_ERROR] socket\n");
  7.                 return -1;
  8.         }
  9.  
  10.         int opt = 1;
  11.         setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
  12.         bzero(&server, sizeof(server));
  13.         server.sin_family = AF_INET;
  14.         server.sin_port = htons(PORT);
  15.         server.sin_addr.s_addr = htonl(INADDR_ANY);
  16.  
  17.         if(bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1){
  18.                 perror("[SERVER_ERROR] bind\n");
  19.                 return -1;
  20.         }
  21.  
  22.         addrlen = sizeof(client);
  23.  
  24.         FILE* fp = fopen(INDEX_NAME,"r");
  25.         if(fp == NULL){
  26.                 perror("[SERVER_ERROR] index.html file\n");
  27.                 return -1;
  28.         }
  29.

把index.html读取出来，返回给客户端

fread(index_body,sizeof(index_body),1,fp);

然后while循环监听并执行事件

  1.  while(1){
  2.  
  3.                 if(listen(listenfd, BACKLOG) == -1){
  4.                         perror("[SERVER_ERROR] listen\n");
  5.                         return -1;
  6.                 }
  7.  
  8.                 if((connectfd = accept(listenfd, (struct sockaddr *)&client, &addrlen)) == -1){
  9.                         perror("[SERVER_ERROR] accept\n");
  10.                         return -1;
  11.                 }
  12.  
  13.                 char buff[1024] = {0};
  14.                 recv(connectfd,buff,1024,0);
  15.                 //printf("%s\n",buff);
  16.                 Http_Exec(GET_HTTP_STATE(buff),connectfd,buff);
  17.                 close(connectfd);
  18.         }

最后的关闭tcpfd

  1.  close(listenfd);
  2.  return 0;

六.在make添加支持

  1. arm-embedsky-linux-gnueabi-gcc ./src/network/server.c -o server
  2. mv server                                       ./arch/arm/network
  3. cp ./src/network/index.html                     ./arch/arm/network

好了到这一步就彻底写完啦。

完整的make：

  1. ifneq ($(KERNELRELEASE),)
  2.         obj-m  := ./src/TQ210_LED/device/TQ210_device_led.o
  3. else
  4.         KDIR := /home/beis/TQ/opt/EmbedSky/TQ210/Kernel_3.0.8_TQ210_for_Linux_v2.4
  5. all:
  6.         $(MAKE) -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-embedsky-linux-gnueabi-
  7.         arm-embedsky-linux-gnueabi-gcc ./src/TQ210_LED/app/TQ210_app_led.c -o TQ210_app_led
  8.         arm-embedsky-linux-gnueabi-gcc ./src/network/server.c -o server
  9.         mv ./src/TQ210_LED/device/*.o                   ./output
  10.         mv *.symvers                                    ./output
  11.         mv *.order                                      ./output
  12.         mv ./src/TQ210_LED/device/*.mod.c               ./output
  13.         mv ./src/TQ210_LED/device/*.ko                  ./arch/arm/TQ210_LED
  14.         mv TQ210_app_led                                ./arch/arm/TQ210_LED
  15.         mv server                                       ./arch/arm/network
  16.         cp ./src/network/index.html                     ./arch/arm/network
  17. clean:
  18.         $(MAKE) -C $(KDIR) M=$(PWD) clean
  19.         rm ./output/*
  20.         rm ./arch/arm/TQ210_LED/*
  21.         rm ./arch/arm/network/*
  22. endif

git保存

  1. git add .
  2. git commit -m "three"

七. 最终演示

使用你的方式在把arch/arm下两个目录的文件全部传输到开发板

我用的是dropbear

然后ssh登入进去执行。

我们是ssh登入进去的，所以很多命令都在/sbin目录下

加载模块：

/sbin/insmod TQ210_device_led.ko

然后查看一下日志

可以看到成功加载。

然后我们在运行app demo演示：

在看一下server演示：

​

因是GIF所以比较模糊，大家可以自行测试

这里是github的项目地址：https://github.com/beiszhihao/Internet-of-things-project

日后所有基于物联网的项目我都会开源在这个仓库中

欢迎大家star

原文链接:https://blog.csdn.net/bjbz_cxy/article/details/117595265



所属网站分类: 技术文章 > 博客

作者：狗蛋你别跑

链接：http://www.phpheidong.com/blog/article/89705/39474f9a68ac9a8d382f/

来源：php黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

2 0
收藏该文
已收藏

评论内容：(最多支持255个字符)




程序员的那些事(new)

2022年最受欢迎的8大编程语言

为什么都说程序员找不到女朋友，但是身边程序猿的却没一个单身的

程序员被开除，老板：“有你参与的项目全黄了！”

笑话：一个测试工程师走进一家酒吧

趣图：程序员头疼的4种原因

笑话：面试官：请拿出一段体现你水平的代码。我： sudo rm -rf /*面试官：这体现了你哪方面能力？

php精选：aardio + PHP 可视化快速开发独立 EXE 桌面程序

程序人生：程序员如何实现财富自由？

找工作千万不要找外包？BAT互联网大厂外包亲身经历

程序员的工资这么高，为什么还会有人离职？

电子书(new)

PHP Cookbook：PHP程序员的解决方案和示例 pdf

PHP核心技术与最佳实践 pdf

PHP高级程序设计：模式，框架与测试 pdf

PHP程序设计 pdf

PHP精粹：编写高效的PHP代码 pdf

深度PHP：面向对象，模式与实践（第2版）pdf

PHP与MySQL 5程序设计（第2版） pdf

搜索引擎优化高级编程：使用PHP进行专业搜索引擎优化 pdf

PHP和MySQL Web开发（原书第4版）pdf下载

现代PHP（中文版）pdf下载

脚本(new)

用PHP创建的在线寻宝游戏

保龄球游戏卡塔使用PHP和PHPUnit

一个用php编写的国际象棋游戏

使用PHP后端的实时多人游戏

基于PHP的在线寻宝游戏

jQuery和PHP扑克游戏

PHP德州扑克游戏​

PHP中的保龄球游戏Kata

在线角色扮演游戏

由PHP IRC机器人提供支持的热门狼人游戏（黑手党的变种）

博客(new)

打包部署若依(RuoYi)SpringBoot后端和Vue前端图文教程

MS SQL Server 实战 统计与汇总重复记录

MySQL中的增查操作：探索数据的奥秘，开启数据之门

[SpringBoot] 苍穹外卖--面试题总结--上

【MySQL】窗口函数详解（概念+练习+实战）

Spring中的@Autowired注解：深入解析与实战指南

MySQL 读写分离

【随时随地学算法】本地部署hello-algo结合内网穿透远程学习新体验

解锁MySQL的潜力：掌握修改、删除和约束的关键技巧

2019年系统架构师案例分析试题五

视频教程(new)

正则表达式极速入门

php从零开始开发属于自己的php框架

Thinkphp3.2.3个人博客开发

ThinkPHP5快速开发企业站点[全程实录]

ThinkPHP5实战之[教学管理系统]

PHP视频教程

ThinkPHP5视频教程

CI框架30分钟极速入门

PHP实战微信支付视频教程

PHP实战仿爱奇艺电影网站，视频教程

项目实战(new)

PHP发送邮件功能

PHP注册时短信通知功能

smarty模板引擎[函数篇]

PHP制作阴阳历转换的日历插件

PHP项目开发案例全程实录视频及源码

PHP 发表评论功能实战教程

布尔教育Blog项目实战视频教程

Yii2框架搭建完整博客系统

Laravel5.2博客实战视频教程

Thinkphp3.2.3个人博客开发实战

问答(new)

VerifyCsrfToken laravel5.3 中是否存在 TokenMismatchException？

Laravel 使用嵌套使用多个类

在 PHP 中设置 CURL 连接和执行超时

通过 SSH 使用 mysql（php）

使用 php 中的按钮删除或编辑数据库中的行

PHP OpenCloud/OpenStack 如何创建供公共访问的容器

如何将mysql数据库中提取的值从一个php文件传递到另一个php文件

可变产品下拉菜单不会出现在自定义产品页面中

Woocommerce 的小部件部分在移动设备上显示在主要内容之后

无法在 Google Classroom API 中使用批处理请求

游戏(new)

Conway的PHP生活游戏

用PHP和JavaScript编写的UNO游戏

国际象棋游戏-php

php贪吃蛇游戏-源码下载

一个基于PHP的在线足球游戏

PHP小游戏-进击吧战士

php小游戏源码下载

php斗地主游戏

php贪吃蛇游戏源码下载

PHP玩微信跳一跳，源码下载

其他资源(new)

PHP函数string字符串函数视频讲解

php开发验证码最新视频教程

PHP函数之array数组函数视频讲解

PHP模糊查询技术视频教程

php新闻发布系统视频教程

PHP留言板制作经典视频教程

PHP学生管理系统视频教程

PHP入门视频教程之一周学会PHP

命名空间30分钟极速入门

PHP字符串操作经典入门