嵌入式驱动学习第三周——linux内核链表

前言

   在 Linux 内核中使用最多的数据结构就是链表了，其中就包含了许多高级思想。 比如面向对象、类似C++模板的实现、堆和栈的实现。

   嵌入式驱动学习专栏将详细记录博主学习驱动的详细过程，未来预计四个月将高强度更新本专栏，喜欢的可以关注本博主并订阅本专栏，一起讨论一起学习。现在关注就是老粉啦！

目录

  • 前言
  • 1. 链表简介
    • 1.1 单链表
    • 1.2 双链表
    • 1.3 循环链表
  • 2. 内核链表
    • 2.1 list_head
    • 2.2 链表初始化
    • 2.3 增删改查
      • 2.3.1 添加节点
      • 2.3.2 删除节点
      • 2.3.3 遍历操作
    • 2.4 搬移
    • 2.5 其他
  • 3. 实际案例
    • 3.1 定义自己的结构体
    • 3.2 初始化链表
    • 3.3 增删改查函数定义
    • 3.4 调用
    • 3.5 完整代码
  • 参考资料

1. 链表简介

   链表作为常用的数据结构，是使用指针将一系列数据连成一条链，是一种线性表，通常链表数据结构至少应包括两个域，数据域和指针域。数据域用于存储数据，指针域用于建立与下一个节点的联系。相信其特性也不需要过多介绍了，大部分人应该都知道的，这部分就简单过一遍

1.1 单链表

   单链表，其仅有一个指针域指向后继节点，对单链表只能从头到顺序访问

在这里插入图片描述

1.2 双链表

   双链表多了一个指针域，又后继和前驱，既能从头到尾，又能从尾到头访问

在这里插入图片描述

1.3 循环链表

   循环链表是在单链表与双链表的基础上，让最后一个节点的指针域指向最开始的节点，双链表的话第一个节点的前驱也要指向最后一个节点。好处是可以从任意一个节点开始访问完全部的节点。

在这里插入图片描述

2. 内核链表

   在Linux内核中使用了大量的链表结构来组织数据，包括设备列表以及各种功能模块中的数据组织。这些链表大多采用在include/linux/list.h实现的一个相当精彩的链表数据结构。事实上，内核链表就是采用双循环链表机制，支持FIFO（先进先出）和LIFO（后进先出）操作。

   通过使用循环链表，内核开发者可以在保持代码量最小的情况下实现多种数据结构和算法，提高了内核的性能和可维护性。此外，循环双链表还具有高效地插入和删除节点的优点，在内核开发中很重要，因为内核需要频繁地对数据结构进行修改和操作。

   内核链表有别于传统链表就在节点本身不包含数据域，只包含指针域。故而可以很灵活的拓展数据结构。

2.1 list_head

   这个结构自身意义不大，但是在内核链表中，起着衔接的作用，可以说是内核链表的核心

struct list_head {
   struct list_head *next, *prev;
};

2.2 链表初始化

   初始化分为宏初始化和借口初始化

   宏初始化主要有LIST_HEAD_HEAD_INIT和LIST_HEAD。

LIST_HEAD_HEAD_INIT 宏，对于任意给定的结构指针，将【前驱】和【后继】指针都指向自己，作为链表头指针
LIST_HEAD 本质就是赋予了 name有list_head属性，是基于LIST_HEAD_HEAD_INIT 宏的视线

#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
   struct list_head name = LIST_HEAD_INIT(name)

   接口初始化比较直白，INIT_LIST_HEAD和宏实现意图相同，直接将链表头指针的前驱和后继都指向自己，定义如下：

static inline void INIT_LIST_HEAD(struct list_head *list)
{
   list->next = list;
   list->prev = list;
}

   要使用list_head的话，就需要创建一个宿主结构，让其包含list_head。

typedef struct my_list {
	int val;
	struct list_head list;
} My_List;

   然后我们根据这个结构体创建一个节点：

My_List first_node = {
	.val = 10,
	.list = LIST_HEAD_INIT(first_node.list);	// 将first_node.list的前驱和后继均指向自己

   即如下所示：

在这里插入图片描述

   此处list_node高能的地方又来了，我们知道container_of宏可以根据成员查找到结构体，那么通过结合container_of宏就可以通过list_node成员访问到结构体，然后再根据结构体访问其中的数值。

   container_of文章地址：嵌入式驱动学习第三周——container_of()宏

2.3 增删改查

2.3.1 添加节点

   添加节点使用的是list_add函数，其是头部插入，即总是在链表的头部插入，链表是向左生长的。其底层调用的是__list_add函数。

/* 
 * @description: 添加内核链表节点，头插法
 * @param-new  : 要添加的新节点
 * @param-head : 要加入链表的头节点
 * @return     : 无
 */
static inline void list_add(struct list_head *new, struct list_head *head)
{
   __list_add(new, head, head->next);
}

static inline void __list_add(struct list_head *new,
         struct list_head *prev,
         struct list_head *next)
{
   next->prev = new;
   new->next = next;
   new->prev = prev;
   prev->next = new;
}

   举例说明，首先可以创建一个头节点

LIST_HEAD(listHead);

在这里插入图片描述

   然后用2.2中的方法创建第一个节点

struct my_data_list first_data =
{ 
    .val = 1,
    .list = LIST_HEAD_INIT(first_data.list),
};

   创建完毕后用list_add函数将其加入到头结点中

list_add(&frist_data.list, &listHead);

在这里插入图片描述

   然后创建第二个节点并添加进去，注意看第二个节点添加的位置，是在定义的头结点之后，即头部插入

struct my_data_list second_data =
{ 
    .val = 2,
    /* 也可以调用接口 初始化*/
    .list = LIST_HEAD_INIT(second_data.list),
};
 
list_add(&second_data.list, &listHead);

在这里插入图片描述

   另一种是使用尾插法，即在节点尾部添加节点，函数为list_add_tail函数，其也是调用的__list_add函数，但是调用的时候二三两个参数位置反了一下：

/* 
 * @description: 添加内核链表节点，尾插法
 * @param-new  : 要添加的新节点
 * @param-head : 要加入链表的头节点
 * @return     : 无
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
   __list_add(new, head->next, head);
}

   前面操作一样，来看插入第二个节点时的操作，注意看第二个节点插入的位置，是在第一个节点之后。

struct my_data_list second_data =
{ 
    .val = 2,
    /* 也可以调用接口 初始化*/
    .list = LIST_HEAD_INIT(second_data.list),
};
 
list_add_tail(&second_data.list, &listHead);

在这里插入图片描述

2.3.2 删除节点

   删除节点采用list_del函数或list_del_init函数

/* 
 * @description: 删除指定节点，并将节点指向特定位置
 * @param-entry: 要删除的节点
 * @return     : 无
 */
static inline void list_del(struct list_head *entry)

/* 
 * @description: 删除指定节点，删除后将节点置为空链状态，即前驱和后继均指向自己
 * @param-entry: 要删除的节点
 * @return     : 无
 */
static inline void list_del_init(struct list_head *entry)

2.3.3 遍历操作

   遍历也是一个相当重要也是相当常用的操作，首先需要介绍一下list_entry宏，list_entry宏本质是container_of宏：

#define list_entry(ptr, type, member) \
   container_of(ptr, type, member)

   其使用方法和container_of是一致的：

list_entry(&my_list_data.list, typeof(&my_list_data), list)

   既然是双向链表，那肯定就可以正向遍历，也可以反向遍历。

   list_for_each 它实际上是一个for循环，利用传入的pos作为循环变量，从表头head开始，逐项向后（next方向）移动pos，直至又回到head

/* 
 * @description: 正向遍历双向链表
 * @param-pos  : 一个list_node指针，作为遍历指针
 * @param-head : 要遍历链表的头结点
 * @return     : 无
 */
#define list_for_each(pos, head) \
 for (pos = (head)->next; pos != (head); pos = pos->next)

   其使用方法如下：

struct my_data_list* p;
struct list_head *pos; //pos指向每一个大结构体中的小结构体
list_for_each(pos, &(Head->list)) //循环遍历
{
    //以上循环只提供小结构体指针的遍历，但是遍历找的是大结构体的数据域，根据每个pos得到大结构体地址
    p = list_entry(pos, Node, list);
    printk(p->data);  //打印 
}

   list_for_each_entry 是遍历每一个list，然后获取宿主的结构地址：

/* 
 * @description : 正向遍历双向链表并获取宿主的结构地址
 * @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量
 * @param-head  : 要遍历链表的头结点
 * @param-member: 自己结构体中list_head的名称
 * @return      : 无
 */
#define list_for_each_entry(pos, head, member)    \
 for (pos = list_entry((head)->next, typeof(*pos), member); \
      &pos->member != (head);  \
      pos = list_entry(pos->member.next, typeof(*pos), member))

   使用案例：

struct my_data_list* p;
list_for_each_entry(p, &(Head->list), list) //循环遍历，最后一个参数是list是因为我结构体中list_head成员名字叫list
{
    printk(pos->val);  //打印
}

   list_for_each_prev是反向遍历，用法同list_for_each

/* 
 * @description: 反向遍历双向链表
 * @param-pos  : 一个list_node指针，作为遍历指针
 * @param-head : 要遍历链表的头结点
 * @return     : 无
 */
#define list_for_each_prev(pos, head) \
 for (pos = (head)->prev; pos != (head); pos = pos->prev)

   list_for_each_entry_reverse是反向遍历，用法同list_for_each_entry

/* 
 * @description : 正向遍历双向链表并获取宿主的结构地址
 * @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量
 * @param-head  : 要遍历链表的头结点
 * @param-member: 自己结构体中list_head的名称
 * @return      : 无
 */
#define list_for_each_entry_reverse(pos, head, member)   \
   for (pos = list_entry((head)->prev, typeof(*pos), member); \
        &pos->member != (head);  \
        pos = list_entry(pos->member.prev, typeof(*pos), member))

2.4 搬移

   内核提供了将原本属于一个链表的节点移动到另一个链表的操作，并根据插入到新链表的位置分为两类：头部搬移和尾部搬移。搬移的本质就是删除加插入。

/* 
 * @description: 从一个链表删除并添加到另一个链表中，头插法添加
 * @param-list : 要移动的节点
 * @param-head : 要添加进的链表的头结点
 * @return     : 无
 */
static inline void list_move(struct list_head *list, struct list_head *head)

/* 
 * @description: 从一个链表删除并添加到另一个链表中，尾插法添加
 * @param-list : 要移动的节点
 * @param-head : 要添加进的链表的头结点
 * @return     : 无
 */
static inline void list_move_tail(struct list_head *list, struct list_head *head)

2.5 其他

   还有其他操作比如合并，替换等，详情可见参考资料[1]。

3. 实际案例

3.1 定义自己的结构体

   定义一个工程师类，然后定义一个公司类，把工程师放进去，然后最外层定义一个node，数据域就是公司，指针域就是list_head变量。

// 一个公司类
typedef struct company_Struct {
    char name[100];
    int company_val;
    int employee_count;     // 员工人数
} Company;

typedef struct my_node {
    // 数据域
    Company company;

    // 指针域
    struct list_head list;
}Node, *pNode;

3.2 初始化链表

   之后初始化一个链表，即构建一个头节点。

// 链表初始化，构建一个头节点
pNode List_Init(void) {
    pNode Head = (pNode)malloc(sizeof(Node));
    if (Head == NULL) {
        perror("malloc failed!");
        return NULL;
    }

    INIT_LIST_HEAD(&Head->list);

    return Head;
}

3.3 增删改查函数定义

   之后写一些增加节点，删除节点，遍历节点的函数。

   增加节点，首先先创建一个节点，然后再添加进去。

// 增加节点函数
int Node_Insert(pNode head, Company elem)
{
    pNode newNode = (pNode)malloc(sizeof(Node));
    if (newNode == NULL) {
        perror("malloc failed!");
        return -1;
    }

    newNode->company = elem;

    list_add(&(newNode->list), &(head->list));

	return 0;
}

   删除节点，在调用list_del函数后，要用free释放节点

// 删除节点
void Node_Delete(Company elem) {
    pNode delNode = list_entry(&elem, Node, company);
    list_del(&(delNode->list));
    free(delNode);
}

   遍历函数

// 遍历节点
void List_Traversal(pNode head) {
    pNode p;
    struct list_head *pos;
    list_for_each(pos, &(head->list)) {
        p = list_entry(pos, Node, list);
        printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);
    }
}

3.4 调用

Company com1 = {"aaaa", 100, 10};
Company com2 = {"bbbb", 200, 8};
Company com3 = {"cccc", 300, 40};

pNode head = List_Init();        // 初始化一个列表
Node_Insert(head, com1);
Node_Insert(head, com2);
Node_Insert(head, com3);

printk("+++++++所有的节点+++++++");
List_Traversal(head);

Node_Delete(com2);
printk("+++++++删除部分节点+++++++");
List_Traversal(head);

3.5 完整代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/of_device.h>
#include <linux/list.h>
#include <stdlib.h>

#define chrdevTest_CNT      1
#define chrdevTest_NAME     "chrdevTest"

// 一个公司类
typedef struct company_Struct {
    char name[100];
    int company_val;
    int employee_count;     // 员工人数
} Company;

typedef struct my_node {
    // 数据域
    Company company;

    // 指针域
    struct list_head list;
}Node, *pNode;

// 设备结构体
struct chrdevTest_dev {
    dev_t devid;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    int major;
    int minor;
    struct device_node *nd;
};

struct chrdevTest_dev chrdevTest;   // 字符设备

// 链表初始化，构建一个头节点
pNode List_Init(void) {
    pNode Head = (pNode)malloc(sizeof(Node));
    if (Head == NULL) {
        printk("malloc failed!");
        return NULL;
    }

    INIT_LIST_HEAD(&Head->list);

    return Head;
}

// 增加节点函数
int Node_Insert(pNode head, Company elem)
{
    pNode newNode = (pNode)malloc(sizeof(Node));
    if (newNode == NULL) {
        printk("malloc failed!");
        return -1;
    }

    newNode->company = elem;

    list_add(&(newNode->list), &(head->list));

    return 0;
}

// 删除节点
void Node_Delete(Company elem) {
    pNode delNode = list_entry(&elem, Node, company);
    list_del(&(delNode->list));
    free(delNode);
}

// 遍历节点
void List_Traversal(pNode head) {
    pNode p;
    struct list_head *pos;
    list_for_each(pos, &(head->list)) {
        p = list_entry(pos, Node, list);
        printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);
    }
}

static int chrdevTest_open(struct inode *inode, struct file *filp) {
    filp->private_data = &chrdevTest;
    return 0;
}

static ssize_t chrdevTest_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {
    return 0;
}

static ssize_t chrdevTest_write(struct file *filp, const char __user* buf, size_t cnt, loff_t* offt) {
    return 0;
}

static ssize_t chrdevTest_release(struct inode* inode, struct file* filp) {
    return 0;
}

static struct file_operations chrdevTest_fops = {
    .owner = THIS_MODULE,
    .open = chrdevTest_open,
    .read = chrdevTest_read,
    .write = chrdevTest_write,
    .release = chrdevTest_release,
};

// 入口函数
static int __init containerTest_init(void)
{
    Company com1 = {"aaaa", 100, 10};
    Company com2 = {"bbbb", 200, 8};
    Company com3 = {"cccc", 300, 40};

    pNode head = List_Init();        // 初始化一个列表
    Node_Insert(head, com1);
    Node_Insert(head, com2);
    Node_Insert(head, com3);

    printk("+++++++所有的节点+++++++");
    List_Traversal(head);

    Node_Delete(com2);
    printk("+++++++删除部分节点+++++++");
    List_Traversal(head);

    if (chrdevTest.major) {
        chrdevTest.devid = MKDEV(chrdevTest.major, 0);
        register_chrdev_region(chrdevTest.devid, chrdevTest_CNT, chrdevTest_NAME);
    } else {
        alloc_chrdev_region(&chrdevTest.devid, 0, chrdevTest_CNT, chrdevTest_NAME);     // 申请设备号
        chrdevTest.major = MAJOR(chrdevTest.devid);     // 获取主设备号
        chrdevTest.minor = MINOR(chrdevTest.devid);     // 获取次设备号
    }
    printk("chrdevTest major=%d, minor=%d\r\n", chrdevTest.major, chrdevTest.minor);

    // cdev
    chrdevTest.cdev.owner = THIS_MODULE;
    cdev_init(&chrdevTest.cdev, &chrdevTest_fops);

    // 添加cdev
    cdev_add(&chrdevTest.cdev, chrdevTest.devid, chrdevTest_CNT);

    // 创建类
    chrdevTest.class = class_create(THIS_MODULE, chrdevTest_NAME);
    if (IS_ERR(chrdevTest.class)) {
        return PTR_ERR(chrdevTest.class);
    }

    // 创建设备
    chrdevTest.device = device_create(chrdevTest.class, NULL, chrdevTest.devid, NULL, chrdevTest_NAME);
    if (IS_ERR(chrdevTest.device)) {
        return PTR_ERR(chrdevTest.device);
    }

    return 0;
}

// 出口函数
static void __exit containerTest_exit(void)
{
    printk("this is exit function\r\n");

    cdev_del(&chrdevTest.cdev);
    unregister_chrdev_region(chrdevTest.devid, chrdevTest_CNT);

    device_destroy(chrdevTest.class, chrdevTest.devid);
    class_destroy(chrdevTest.class);
}


module_init(containerTest_init);
module_exit(containerTest_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wp");

参考资料

[1] 一文搞懂 Linux 内核链表（深度分析）
[2] 【内核链表】数据结构——深入理解内核链表的概念和操作&笔记

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/453514.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

智能指针的讲解

智能指针的讲解

1.为什么要智能指针 首先我们分析一段代码&#xff1a; 1、如果p1这里new 抛异常会如何&#xff1f; 2、如果p2这里new 抛异常会如何&#xff1f; 3、如果div调用这里又会抛异常会如何&#xff1f; int div() {int a, b;cin >> a >> b;if (b 0)throw invalid_ar…
阅读更多...
CVE-2024-2074 SpringBoot迷你天猫商城Mini-Tmall sql注入漏洞分析

CVE-2024-2074 SpringBoot迷你天猫商城Mini-Tmall sql注入漏洞分析

漏洞简介 Mini-Tmall是一个基于Spring Boot的迷你天猫商城。Mini-Tmall在20231017版本及之前存在一个严重的漏洞&#xff0c;攻击者可以利用该漏洞通过远程执行特定操作来注入恶意SQL语句&#xff0c;从而获取敏感信息或控制数据库。此漏洞影响文件?rtmall/admin/user/1/1的一…
阅读更多...
下载API文档

下载API文档

在线看&#xff1a;Overview (Java SE 17 & JDK 17) 离线下载&#xff1a;Java Development Kit 17 Documentation
阅读更多...
Python 单元测试

Python 单元测试

本篇为Python的单元测试的方法及示例 目录 概念 结果 示例 对函数进行测试 创建函数文件 创建测试文件 测试结果 对类进行测试 创建待测试类 创建测试文件 文档测试 创建函数 进行测试 总结 概念 用来对一个函数、一个类或者一个模块来进行正确性校验工作 结果 …
阅读更多...
为什么选择线上展览馆，搭建线上展览馆要注意什么

为什么选择线上展览馆，搭建线上展览馆要注意什么

引言&#xff1a; 线上展览馆是一种利用互联网技术&#xff0c;将实体展览馆的展示内容以数字化形式呈现出来的在线观展方式。它打破了时间和空间的限制&#xff0c;使得更多的人可以随时随地参观展览&#xff0c;领略文化的魅力。 一、线上展览馆的优势 1.成本效益高&#x…
阅读更多...
【安卓】Android开发入门 你的第一个apk应用

【安卓】Android开发入门 你的第一个apk应用

本文介绍如何写一个入门的安卓apk应用, 以嵌套一个网页为例。 开发ide&#xff1a;Android studio 语言&#xff1a;Kotlin tips: 最好别下载新版本的 Android studio &#xff0c;因为新版的界面有所改动 遇到问题去网上搜 新手刚入门可能界面都找不到在哪里&#xff1b;其次…
阅读更多...
05-延迟任务精准发布文章-黑马头条

05-延迟任务精准发布文章-黑马头条

延迟任务精准发布文章 1)文章定时发布 2)延迟任务概述 2.1)什么是延迟任务 定时任务&#xff1a;有固定周期的&#xff0c;有明确的触发时间延迟队列&#xff1a;没有固定的开始时间&#xff0c;它常常是由一个事件触发的&#xff0c;而在这个事件触发之后的一段时间内触发…
阅读更多...
银河麒麟V10SP3操作系统-网络时间配置

银河麒麟V10SP3操作系统-网络时间配置

1、动态网络配置 打开终端&#xff0c;以网口 eth0 为例&#xff1a; nmcli conn add connection.id eth0-dhcp type ether ifname eth0 ipv4.method auto其中“eth0-dhcp”为连接的名字&#xff0c;可以根据自己的需要命名方便记忆和操作 的名字&#xff1b;“ifname eth0”…
阅读更多...
Realsense 相机SDK学习（一）——librealsense使用方法及bug解决（不使用Ros）

Realsense 相机SDK学习（一）——librealsense使用方法及bug解决（不使用Ros）

一.介绍 realsense相机是一个intel开发出来的一款深度相机&#xff0c;我之前使用他来跑过slam&#xff0c;也配置过他的驱动&#xff0c;在此附上realsense的相机驱动安装方法&#xff1a;Ubuntu20.04安装Intelrealsense相机驱动&#xff08;涉及Linux内核降级&#xff09; …
阅读更多...
redis-操作数据库

redis-操作数据库

0 序言 一个Redis服务器可以包含多个数据库。在默认情况下&#xff0c;Redis服务器在启动时将会创建16个数据库&#xff1a;这些数据库都使用号码进行标识&#xff0c;其中第一个数据库为0号数据库&#xff0c;第二个数据库为1号数据库&#xff0c;而第三个数据库则为2号数据库…
阅读更多...
Leetcode101对称的二叉树

Leetcode101对称的二叉树

如何去检查对称&#xff1f; 思路是check(n1->left,n2->right)&&check(n1->right,n2->left) 直接手算这题&#xff0c;该懂就懂了&#xff01; /*** Definition for a binary tree node.* struct TreeNode {* int val;* TreeNode *left;* Tre…
阅读更多...
【一】【设计模式】类关系UML图

【一】【设计模式】类关系UML图

1. 继承&#xff08;Generalization&#xff09; 继承是对象间的一种层次关系&#xff0c;允许子类继承并扩展父类的功能。 UML线&#xff1a;带有空心箭头的直线&#xff0c;箭头指向基类&#xff08;父类&#xff09;。 class Parent {public void parentMethod() {System.…
阅读更多...
Python网络基础爬虫-python基本语法

Python网络基础爬虫-python基本语法

文章目录 逻辑语句if,else,elifforwhile异常处理 函数与类defpassclass 逻辑语句 熟悉C/C语言的人们可能很希望Python提供switch语句&#xff0c;但Python中并没有这个关键词&#xff0c;也没有这个语句结构。但是可以通过if-elif-elif-…这样的结构代替&#xff0c;或者使用字…
阅读更多...
哈密顿算子的计算公式及一些常用公式总结

哈密顿算子的计算公式及一些常用公式总结

目录 哈密顿算子的定义式如下&#xff1a; 梯度定义&#xff1a; 散度定义&#xff1a; 旋度定义&#xff1a; 常用的一些公式&#xff1a; 注意文中字母上面没有→的是标量&#xff0c;有→的都表示矢量 哈密顿算子的定义式如下&#xff1a; 快速了解哈密顿算符&#xff…
阅读更多...
同步整流芯片 支持12V降5V 24V降5V 24V降12V 降压芯片 H4122

同步整流芯片 支持12V降5V 24V降5V 24V降12V 降压芯片 H4122

惠海H4122降压恒压芯片的工作原理&#xff1a; 主要是通过内部电路和算法来控制和调节输出电压&#xff0c;使其保持恒定。 输入电压&#xff1a;芯片接收一个较高的输入电压&#xff0c;如12V、24V或36V。 开关电源转换器&#xff1a;芯片内部通常包含一个或多个开关电源转…
阅读更多...
Linux 安装Nginx (Nginx-1.25.4)

Linux 安装Nginx (Nginx-1.25.4)

一、下载Nginx安装包 1.服务器联网的情况下&#xff0c;使用wget命令把Nginx安装包下载到/usr/local/目录中&#xff0c;如果没有wget命令&#xff0c;需要先安装&#xff1a;yum install -y wget cd /usr/local wget -c https://nginx.org/download/nginx-1.25.4.tar.gz ng…
阅读更多...
Kanebo HITECLOTH 高科技擦镜布介绍

Kanebo HITECLOTH 高科技擦镜布介绍

Kanebo HITECLOTH&#xff0c;这款由日本KBSeiren公司制造的高科技擦镜布&#xff0c;以其卓越的清洁能力和超柔软的布质&#xff0c;成为了市场上备受瞩目的产品。 材质与特性 HITECLOTH采用0.1旦尼尔特级高级微纤维制造&#xff0c;质地细致、坚韧、不起颗粒。这种纤维的特…
阅读更多...
基于单片机的PM2.5浓度检测及报警系统设计与实现

基于单片机的PM2.5浓度检测及报警系统设计与实现

基于单片机的PM2.5浓度检测及报警系统设计与实现 II 摘 要 II Abstract III 第一章 前言 1 1.1、设计的目的和意义 1 1.2、设计的发展趋势及国内外现状 2 第二章　主要元器件选择 4 2.1、AT89C51单片机 4 2.3、A/D转换芯片ADC0832 8 2.4、LCD1602液晶显示屏 10 第三章 设计各模…
阅读更多...
TOUGH软件教程

TOUGH软件教程

原文链接&#xff1a;TOUGH软件教程https://mp.weixin.qq.com/s?__bizMzUzNTczMDMxMg&mid2247597252&idx6&sna9da64e502f070dcc37f9a93dd2a017b&chksmfa823d23cdf5b435996a4a7ebbed78211e81290c37138bcace1f4156f6588af829008381bc16&token1065483158&…
阅读更多...
RocketMQ为什么这么快？我从源码中扒出了10大原因！

RocketMQ为什么这么快？我从源码中扒出了10大原因！

RocketMQ作为阿里开源的消息中间件&#xff0c;深受广大开发者的喜爱 而这其中一个很重要原因就是&#xff0c;它处理消息和拉取消息的速度非常快 那么&#xff0c;问题来了&#xff0c;RocketMQ为什么这么快呢&#xff1f; 接下来&#xff0c;我将从以下10个方面来探讨一下…
阅读更多...
最新文章

Copyright @ 2022~2023