Linux 驱动入门（1）—— hello驱动

已于 2024-08-12 15:43:47 修改
阅读量566 收藏 14
点赞数 20
分类专栏： Linux驱动 文章标签： linux 驱动
于 2024-08-12 15:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74712453/article/details/140208323
版权

目录

前言

一、编译替换内核和设备树

二、驱动入门知识

三、编写最简单的 Hello 驱动

1. 整体框架流程图

2. 编写第一个Hello程序

3. 编写第二个Hello程序（改进第一个）

4. 编写第三个Hello程序（改进第二个）

前言

在这里主要记录学习韦东山老师Linux驱动课程的笔记，韦东山老师的驱动课程讲的非常好，想要学习驱动的小伙伴可以去b站学习他的课程。

一、编译替换内核和设备树

在编译驱动程序之前要先编译内核，原因有三点：

  • 驱动程序要用到内核文件
  • 编译驱动时用的内核、开发板上运行到内核，要一致
  • 更换板子上的内核后，板子上的其他驱动也要更换

编译内核步骤看我之前写过的文章，编译替换内核_设备树_驱动_IMX6ULL-CSDN博客

二、驱动入门知识

1.首先我们通常都是在Linux的终端上打开一个可执行文件，然后可执行文件就会执行程序。那么这个可执行文件做了什么呢？

2.可执行文件先是在应用层读取程序，其中会有很多库函数，库函数是属于内核之中。而内核又会往下调用驱动层程序。最终驱动层控制具体硬件。

  • 其实应用程序到库是比较容易理解的，比如我们刚学习C语言的时候，使用了printf，scanf等等这些函数。而这些函数就在库中。
  • 库可以和系统内核相连接，具体怎么实现的我也不太清楚。
  • 我们写了一个驱动程序，就需要告诉内核，这个过程叫做注册。我们注册了驱动之后，内核里面就会有这个驱动程序的信息，然后上层应用就可以调用。

3.所以我们只需要知道，咱们需要编写两个程序，一个是驱动层的，一个是应用层的，最后驱动层需要注册进入内核，应用层才能够使用。其他的先不要管。

4.我们在应用层调用read函数，对应驱动层的read函数。write函数和write函数对应。open函数和open函数对应。close函数和release函数对应（这个为什么不一样我们也不用管）。

5.我们对 Linux 应用程序对驱动程序的调用流程有一个简单了解之后，我得知道整个程序编写流程应该怎么做。至于流程为什么是这样的，我们记住即可。因为这些都是人规定的，如果之后学的深了再进行深究也不迟，现在我们主要是入门。

三、编写最简单的 Hello 驱动

1. 整体框架流程图

​

编写驱动主要为以下七个步骤：

  1. 确定主设备号，也可以让内核分配
  2. 定义自己的 file_operations 结构体
  3. 实现对应的 drv_open/drv_read/drv_write 等函数，填入 file operations 结构体
  4. 把 file_operations 结构体告诉内核: register_chrdev
  5. 谁来注册驱动程序啊? 得有一个入口函数:安装驱动程序时，就会去调用这个入口函数
  6. 有入口函数就应该有出口函数: 卸载驱动程序时，出口函数调用unregister_chrdev
  7. 其他完善:提供设备信息，自动创建设备节点: class_create,device_create

我们可以进入内核驱动目录查看别人如何写：

cd ~/100ask_imx6ull-sdk/Linux-4.9.88/drivers/char/
grep "register_chrdev" -nwr
  • -n 选项表示输出匹配行的行号。
  • -w 选项表示只匹配整个单词，而不是字符串的一部分。
  • -r 选项表示递归搜索子目录。

2. 编写第一个Hello程序

第一个Hello程序实现：实现调用流程

01_hello_drv目录下创建三个文件，分别是hello_drv.c，hello_test.c，Makefile

hello_drv.c：

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/uaccess.h>

static int major;

static int hello_open (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}
static ssize_t hello_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return size;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return size;
}

static int hello_release (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

/* 1. create file_operations */
static const struct file_operations hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release,
};

/* 2. register_chrdev */

/* 3. entry function */
static int hello_init(void)
{
   major = register_chrdev(0, "100ask_hello", &hello_drv);
   return 0;
}

/* 4. exit function */
static void hello_exit(void)
{
    unregister_chrdev(major, "100ask_hello");
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

  1. module_init(hello_init);：这行代码声明了一个名为hello_init的函数，该函数在模块被加载时会被调用。这个函数通常用于初始化模块所需的资源，如分配内存、注册设备等。

  2. module_exit(hello_exit);：这行代码声明了一个名为hello_exit的函数，该函数在模块被卸载时会被调用。这个函数通常用于释放模块所占用的资源，如释放内存、注销设备等。

  3. MODULE_LICENSE("GPL");：这行代码指定了模块的许可证为GNU通用公共许可证（GPL）。这意味着其他人可以自由地使用、修改和分发这个模块，但必须遵循GPL许可协议的规定。

  4. register_chrdev第一个参数默认为0时，系统自动分配设备号。

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx zgl666
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}
  • <表示不可以省略> 
  • [ 表示可以省略（读或写）]

Makefile：


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o hello_test hello_test.c 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order
	rm -f hello_test

obj-m	+= hello_drv.o

在Ubuntu输入以下命令：可以生成代码链接文件，方便用vscode查阅代码

bear make

批量修改：将"cc"改为"arm-buildroot-linux-gnueabihf-gcc"

​

​

开发板操作：

insmod hello_drv.ko
cat /proc/devices
mknod  /dev/zgl c 240 0
./hello_test /dev/zgl  zgl666
./hello_test /dev/zgl
rmmod hello_drv
  • insmod hello_drv.ko用于将名为hello_drv.ko的内核模块插入到运行中的内核中。
  • cat /proc/devices 查看设备号
  • mknod /dev/zgl c 240 0用于创建一个名为/dev/zgl的字符设备文件。其中，c表示字符设备类型，240是主设备号，0是次设备号。
  • rmmod hello_drv用于从内核中卸载一个动态加载的内核模块。

    在使用Linux系统时，内核模块是可加载和卸载的，这使得系统可以根据需要动态地增加或减少功能。rmmod命令就是用来卸载已经不再需要的内核模块，以释放其占用的资源。

    在这个例子中，hello_drv是要被卸载的内核模块的名称。执行rmmod hello_drv命令后，模块hello_drv将被从内核中移除，如果操作成功，不会有任何输出信息。

    需要注意的是，rmmod命令只能卸载未被使用的模块。如果一个模块当前正在被使用（例如有进程打开了该模块提供的设备文件），则无法通过rmmod命令卸载。可以使用lsmod命令查看当前已加载的模块以及它们的使用情况。

    另外，如果想要在卸载模块时同时删除与其相关的文件，可以使用rmmod -r命令。这通常用于模块的调试和开发过程中。

​

​

3. 编写第二个Hello程序（改进第一个）

第二个Hello程序实现：相比于第一个，第二个可以进行收发数据，自动创建设备，结束时销毁。

目录改成：02_hello_drv_transfer_data

hello_drv.c：

#include "asm/cacheflush.h"
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/uaccess.h>


static struct class *hello_class;
static int major;
static unsigned char hello_buf[100];

static int hello_open (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}
static ssize_t hello_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);

    copy_to_user(buf, hello_buf, len);

    return len;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    copy_from_user(hello_buf, buf, len);

    return len;
}

static int hello_release (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

/* 1. create file_operations */
static const struct file_operations hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release,
};


/* 2. register_chrdev */

/* 3. entry function */
static int hello_init(void)
{
    major = register_chrdev(0, "100ask_hello", &hello_drv);

	hello_class = class_create(THIS_MODULE, "hello_class");
	if (IS_ERR(hello_class)) {
		printk("failed to allocate class\n");
		return PTR_ERR(hello_class);
	}

    device_create(hello_class, NULL, MKDEV(major, 0), NULL, "zgl");  /* /dev/zgl */

   return 0;
}


/* 4. exit function */
static void hello_exit(void)
{
    device_destroy(hello_class, MKDEV(major, 0));

    class_destroy(hello_class);

    unregister_chrdev(major, "100ask_hello");
}


module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx 100ask
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}

上电开发板，可以看到自动创建设备/dev/zgl，不需要我们手动创建：

​

4. 编写第三个Hello程序（改进第二个）

第三个Hello程序实现：相比于第二个，第三个可以用于动态分配一组字符设备号，自行规定分配的设备号的数量，了解一下即可，常用的还是第二种。

目录改成：03_hello_drv_cdev

hello_drv.c：

#include "asm-generic/errno-base.h"
#include "asm/cacheflush.h"
#include "linux/cdev.h"
#include "linux/fs.h"
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/uaccess.h>


static struct class *hello_class;
static struct cdev hello_cdev;
static dev_t dev;

static unsigned char hello_buf[100];

static int hello_open (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}
static ssize_t hello_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);

    copy_to_user(buf, hello_buf, len);

    return len;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    copy_from_user(hello_buf, buf, len);

    return len;
}

static int hello_release (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

/* 1. create file_operations */
static const struct file_operations hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release,
};


/* 2. register_chrdev */

/* 3. entry function */
static int hello_init(void)
{
    int ret;

    // register_chrdev

	ret = alloc_chrdev_region(&dev, 0, 2, "hello");
	if (ret < 0) {
		printk(KERN_ERR "alloc_chrdev_region() failed for hello\n");
		return -EINVAL;
	}

    cdev_init(&hello_cdev, &hello_drv);

    ret = cdev_add(&hello_cdev, dev, 2);
	if (ret)
    {
		printk(KERN_ERR "cdev_add() failed for hello\n");
		return -EINVAL;
    }
		
	hello_class = class_create(THIS_MODULE, "hello_class");
	if (IS_ERR(hello_class)) {
		printk("failed to allocate class\n");
		return PTR_ERR(hello_class);
	}

    device_create(hello_class, NULL, dev, NULL, "zgl");  /* /dev/zgl */
 
    return 0;
}


/* 4. exit function */
static void hello_exit(void)
{
    device_destroy(hello_class, dev);

    class_destroy(hello_class);

    //unregister_chrdev(major, "100ask_hello");
    cdev_del(&hello_cdev);
    unregister_chrdev_region(dev, 2);
}


module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

alloc_chrdev_region(&dev, 0, 2, "hello")是Linux内核编程中的一个函数调用，用于动态分配一组字符设备号。

参数解释：

  • &dev：这是一个指向unsigned int类型的指针，用于存储分配的设备号范围的起始值。
  • 0：这是要分配的第一个设备号。
  • 2：这是要分配的设备号的数量。在这个例子中，它将分配从0到1的两个设备号。
  • "hello"：这是设备的名称，通常用于在/proc/devices文件中标识设备。

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx 100ask
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}

热爱嵌入式的小佳同学
关注
  • 20
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux 驱动开发基础知识——Hello驱动程序（一）
妄北y
01-18 5070
我们学习驱动开发的第一个驱动程序Hello驱动程序驱动
最简单的Linux驱动程序
07-21
下面展示了一个最简单的Linux驱动模块——“Hello, Linux Driver”。 ```c #include <linux/module.h> #include <linux/kernel.h> MODULE_LICENSE("Dual BSD/GPL"); static int hello_init(void) { printk(KERN_...
Linux设备驱动开发入门之——hello驱动
luobeihai的博客
04-05 3497
1. Linux驱动程序的分类 Linux 中主要分为三大类驱动：字符设备驱动、块设备驱动和网络设备驱动。 1、字符设备驱动：因为软件操作设备是是以字节为单位进行的，是按照字节流进行读写操作的一种设备。典型的如LCD、蜂鸣器、SPI、触摸屏等驱动，都属于字符设备驱动的范畴。大部分的驱动程序都是属于字符设备驱动。 2、块设备驱动：块设备驱动是相对于字符设备驱动而定义的，因为块设备被软件操作时，是以块为单位进行操作的（块指的是多个字节组成一个块）。块设备大多指的都是各种存储类类设备，比如EMMC、SD卡、NAN
Linux驱动入门——编写第一个驱动
wei_Embedded_z的博客
12-11 1381
Linux驱动入门——编写第一个驱动 Hello 驱动
linux驱动程序——入门
czw
11-05 350
内核的模块装载器里保存有内核的版本信息，在装载模块时，装载器会比较所保存的内核vermagic与此模块的modinfo段里保存的vermagic信息是否一致，两者一致时，模块才能被装载。Linux内核在使用驱动时首先要装载驱动，在装载过程中进行一些初始化动作（建立设备文件、分配内存等），在驱动程序中需提供相应函数来处理驱动初始化工作，该函数须使用。Linux系统在退出是需卸载Linux驱动，卸载过程中进行一些退出工作（删除设备文件、释放内存等），在驱动程序中需提供相应函数来处理退出工作，该函数须使用。
Linux驱动入门实验班——Hello驱动（后附百问网课程视频链接）
m0_75183905的博客
08-10 871
hello驱动
Linux驱动编程入门——生成设备节点
wuqingquan9512的博客
11-08 561
1、新建一个creat_dev.c文件，分别定义一个class和device的结构体（可以仿照i2c-dev.c文件中的写法）2、填充file_operations结构体（可以仿照i2c-dev.c文件中的写法）3、调用register_chrdev()注册字符设备：先添加加载/卸载模块（可仿照之前写的helloworld驱动代码），然后在加载模块中添加注册字符设备。作用：将填充的file_operations结构体注册成字符设备，由系统自动分配主设备号。
Linux驱动开发入门记录——（二）Hello Driver！
Piamen的博客
09-09 193
驱动开发系列
嵌入式Linux驱动开发基础知识_韦东山——hello驱动程序开发
FourLeafCloverLLLS的博客
09-13 1214
【代码】嵌入式Linux驱动开发基础知识(一)——hello驱动程序开发。
linux 内核驱动 入门,Linux驱动入门——几个简单的Linux 模块
weixin_42531925的博客
05-01 81
模块一：#include #include MODULE_LICENSE ("GPL");int init_module (void){printk (KERN_INFO "Hello world\n");return 0;}void cleanup_module (void){printk (KERN_INFO "Goodbye world\n");}//////////////////////...
深入浅出Linux设备驱动编程入门
06-14
### 深入浅出Linux设备驱动编程入门 #### 一、引言 随着Linux操作系统在各个领域的广泛应用，Linux设备驱动编程成为了一项至关重要的技能。对于Linux软件工程师来说，通常分为两大类：一类是专注于应用程序开发的...
零点起步——ARM嵌入式Linux应用开发入门一书的源代码
08-17
《零点起步——ARM嵌入式Linux应用开发入门》是一本专为初学者设计的教程，旨在引导读者从零开始掌握ARM架构下的嵌入式Linux系统应用开发技能。该书的源代码包含了一系列实践项目和示例，帮助读者在实际操作中加深对...
linux HBA驱动中scsi_host_template .shost_attrs
Wang20122013的博客
08-13 321
scsi_host_template是一个结构体，用于定义SCSI主机（host adapter）的属性和操作。这个模板用于初始化SCSI主机结构体scsi_host_template，它包含了主机的属性、操作函数等。shost_attrs是scsi_host_template结构体中的一个成员，它是一个属性组，用于定义SCSI主机可以支持的属性。每个属性都会有相应的操作函数，这些函数定义了如何读取或写入属性值。例如，一个属性可能有一个show函数来返回当前值，一个store函数来设置新值。
Linux os下借助Qt+libvlc是实现多路拉取摄像头rtsp数据流并实时显示
hanpca的博客
08-13 614
Linux os下 借助Qt+libvlc实现同时拉取多路摄像头的rtsp流解码并显示
linux 调试can0
luthane的博客
08-09 338
如果你的系统没有内置CAN驱动，或者你需要加载特定的CAN驱动，你可能需要按照Linux驱动安装的一般步骤来操作。你还可以配置其他CAN参数，如时间量子（tq）、传播段（prop-seg）、相位段1（phase-seg1）、相位段2（phase-seg2）和重新同步跳跃宽度（sjw）等。在不连接其他设备的情况下进行CAN接口的测试，可以设置CAN接口为回环模式。使用cansend命令向CAN总线发送数据。如果你的CAN硬件支持CAN FD，你还可以配置数据位速率（dbitrate）和启用CAN FD模式。
linux下路由追踪traceroute命令详解
最新发布
qq_44846097的博客
08-13 257
‌traceroute命令是一个网络诊断工具，用于追踪数据包从源点到目的地所经过的路由路径。 它通过向目的地发送一系列的‌UDP或‌ICMP数据包，并记录每个数据包所经过的路由器，来显示数据包到达目的地的路径。traceroute命令的基本用法是在命令提示符后键入“traceroute [选项] 目标主机”，其中目标主机可以是目标主机的域名或IP地址。 ​
GNU/Linux - memtool使用
guoqx的专栏
08-10 238
比如在imx-image-core.bb中，IMAGE_INSTALL += "imx-test" ，在build出来的image文件里就会包含这些工具。烧写到板子上，在文件系统中找到工具就可以使用。在Yocto中为NXP的i.MX系列芯片构建Linux系统时，可以加入一些实用工具，比如直接操作内存的memtool。这些工具在imx-test包中，比如imx-test_git.bb里。或者可以使用预先编译好的二进制工具，copy到板子里来运行也可以。默认读取的是32bit，4字节内容。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

热爱嵌入式的小佳同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值