【LV16 day2 平台总线驱动开发---名称匹配】

一、总线、设备、驱动

硬编码式的驱动开发带来的问题：

  1. 垃圾代码太多
  2. 结构不清晰
  3. 一些统一设备功能难以支持
  4. 开发效率低下

1.1 初期解决思路：设备和驱动分离

​ struct device来表示一个具体设备，主要提供具体设备相关的资源（如寄存器地址、GPIO、中断等等）

​ struct device_driver来表示一个设备驱动，一个驱动可以支持多个操作逻辑相同的设备

​ 带来的问题-------怎样将二者进行关联（匹配）？

​ 硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能

​ 于是引入总线（bus），各种总线的核心框架由内核来实现，通信时序一般由SOC供应商支持

​ 内核中用struct bus_type来表示一种总线，总线可以是实际存在的总线，也可以是虚拟总线：

  1. 实际总线：提供时序通信方式 + 管理设备和驱动
  2. 虚拟总线：仅用来管理设备和驱动（最核心的作用之一就是完成设备和驱动的匹配）

理解方式：

设备：提供硬件资源——男方

驱动：提供驱动代码——女方

总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配

1.2 升级思路：根据设备树，在系统启动时自动产生每个节点对应的设备

初期方案，各种device需要编码方式注册进内核中的设备管理结构中，为了进一步减少这样的编码，引进设备树

二、基本数据类型

2.1 struct device

struct device 
{
    struct bus_type *bus;   //总线类型
    dev_t           devt;   //设备号
    struct device_driver *driver;   //设备驱动
    struct device_node  *of_node;//设备树中的节点，重要
    void    (*release)(struct device *dev);//删除设备，重要
    //.......
}；

2.2 struct device_driver

struct device_driver 
{
    const char      *name;  //驱动名称，匹配device用，重要
    struct bus_type *bus;    //总线类型
    struct module       *owner; //模块THIS_MODULE 
    const struct of_device_id   *of_match_table;//用于设备树匹配 of_match_ptr(某struct of_device_id对象地址) 重要
    //......
};

struct of_device_id
{
    char name[32];//设备名
    char type[32];//设备类型
    char compatible[128]; //用于device和driver的match，重点
};
//用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

三、platform总线驱动

platform是一种虚拟总线，主要用来管理那些不需要时序通信的设备

基本结构图：

在这里插入图片描述

3.1 核心数据类型之platform_device

struct platform_device 
{
    const char    *name;    //匹配用的名字
    int        id;//设备id,用于在该总线上同名的设备进行编号，如果只有一个设备，则为-1
    struct device    dev;   //设备模块必须包含该结构体
    struct resource    *resource;//资源结构体 指向资源数组
    u32        num_resources;//资源的数量 资源数组的元素个数
    const struct platform_device_id    *id_entry;//设备八字
};

struct platform_device_id
{
    char name[20];//匹配用名称
    kernel_ulong_t driver_data;//需要向驱动传输的其它数据
};

struct resource 
{
    resource_size_t start;  //资源起始位置   
    resource_size_t end;   //资源结束位置
    const char *name;      
    unsigned long flags;   //区分资源是什么类型的
};
  
#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_IRQ        0x00000400 
/*
flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如
 
a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；注意不同MEM的地址值不能重叠
 
b -- flags为 IORESOURCE_IRQ   时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值
*/

/**
 *注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe；
 */
int platform_device_register(struct platform_device *);
/**
 *注销：把指定设备从设备列表中删除，如果驱动已匹配则回调驱动方法和设备信息中的release；
 */
void platform_device_unregister(struct platform_device *);

struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num);
/*
    功能：获取设备资源
    参数：dev:平台驱动
        type:获取的资源类型
        num:对应类型资源的序号（如第0个MEM、第2个IRQ等，不是数组下标）
    返回值：成功：资源结构体首地址,失败:NULL
*/

3.2 核心数据类型之platform_driver

struct platform_driver 
{
    int (*probe)(struct platform_device *);//设备和驱动匹配成功之后调用该函数
    int (*remove)(struct platform_device *);//设备卸载了调用该函数
     
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device *, pm_message_t state);
    int (*resume)(struct platform_device *);
    struct device_driver driver;//内核里所有的驱动必须包含该结构体
    const struct platform_device_id *id_table;  //能够支持的设备八字数组，用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束
};

int platform_driver_register(struct platform_driver*pdrv);
/*
    功能：注册平台设备驱动
    参数：pdrv:平台设备驱动结构体
    返回值：成功：0
    失败：错误码
*/
void platform_driver_unregister(struct platform_driver*pdrv);

四、platform的三种匹配方式

2.1 名称匹配：一个驱动只对应一个设备 ----- 优先级最低

2.2 id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

​ device模块中，id的name成员必须与struct platform_device中的name成员内容一致

​ 因此device模块中，struct platform_device中的name成员必须指定

​ driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

2.3 设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高

使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符

​ id_table可不设置，但struct platform_driver成员driver的name成员必须设置

五、名称匹配之基础框架

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
 
//定义资源数组
 
static void device_release(struct device *dev)
{
    printk("platform: device release\n");
}
 
struct platform_device test_device = {
    .id = -1,
    .name = "test_device",//必须初始化
    .dev.release = device_release, 
};
 
static int __init platform_device_init(void)
{
    platform_device_register(&test_device);
    return 0;
}
 
static void __exit platform_device_exit(void)
{
    platform_device_unregister(&test_device);
}
 
module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
 
static int driver_probe(struct platform_device *dev)
{
    printk("platform: match ok!\n");
    return 0;
}
 
static int driver_remove(struct platform_device *dev)
{
    printk("platform: driver remove\n");
    return 0;
}
 
struct platform_driver test_driver = {
    .probe = driver_probe,
    .remove = driver_remove,
    .driver = {
        .name = "test_device", //必须初始化
    },
};
 
static int __init platform_driver_init(void)
{
    platform_driver_register(&test_driver);
    return 0;
}
 
static void __exit platform_driver_exit(void)
{
    platform_driver_unregister(&test_driver);
}
 
module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

设备中增加资源，驱动中访问资源

六、名称匹配之led实例

定义fs4412led_device.c

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#define GPX1CON 0X11000C20
#define GPX1DAT 0X11000C24

#define GPX2CON 0X11000C40
#define GPX2DAT 0X11000C44

#define GPF3CON 0X114001E0
#define GPF3DAT 0X114001E4


void fs4412leds_device_release(struct device* dev)
{
	printk("fs4412leds_device releaseed.\n");
}

struct resource fs4412leds_device_res []=
{
	[0]={.start=GPX1CON,.end=GPX1CON+3,.name="GPX1CON",.flags=IORESOURCE_MEM},
	[1]={.start=GPX1CON,.end=GPX1CON+3,.name="GPX1CON",.flags=IORESOURCE_MEM},
	[2]={.start=GPX2CON,.end=GPX2CON+3,.name="GPX2CON",.flags=IORESOURCE_MEM},
	[3]={.start=GPX2DAT,.end=GPX2DAT+3,.name="GPX2DAT",.flags=IORESOURCE_MEM},
	[4]={.start=GPF3CON,.end=GPF3CON+3,.name="GPF3CON",.flags=IORESOURCE_MEM},
	[5]={.start=GPF3DAT,.end=GPF3DAT+3,.name="GPF3DAT",.flags=IORESOURCE_MEM},

};

struct platform_device fs4412leds_device=
{
	.name="fs4412leds",
	.dev.release= fs4412leds_device_release,
	.resource= fs4412leds_device_res,
	.num_resources=ARRAY_SIZE(fs4412leds_device_res),
};



int __init fs4412leds_device_init(void)
{
	platform_device_register(&fs4412leds_device);
	return 0;
}

void __exit fs4412leds_device_exit(void)
{
	platform_device_unregister(&fs4412leds_device);
}

MODULE_LICENSE("GPL");	

module_init(fs4412leds_device_init);
module_exit(fs4412leds_device_exit);

fs4412_driver.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/atomic.h>
#include "myled.h"
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <linux/platform_device.h>

#define BUF_LEN 100
#define myled_DEV_CNT 3
int major = 11;
int minor = 0;
int myled_num=1;
struct myled_dev
{
	struct cdev mydev;
	volatile unsigned long *pled2_con;
	volatile unsigned long *pled2_dat;

	volatile unsigned long *pled3_con;
	volatile unsigned long *pled3_dat;

	volatile unsigned long *pled4_con;
	volatile unsigned long *pled4_dat;

	volatile unsigned long *pled5_con;
	volatile unsigned long *pled5_dat;
};

struct myled_dev *pgmydev=NULL;


int myled_open(struct inode *pnode,struct file *pfile)
{
	pfile->private_data =(void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));

	return 0;
}



int myled_close(struct inode *pnode,struct file *pfile)
{

	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;

		return 0;
}
void led_on(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		writel(readl(pmydev->pled2_dat)|(0x1<<7),pmydev->pled2_dat);		
		break;
	case 3:
		writel(readl(pmydev->pled3_dat)|(0x1),pmydev->pled3_dat);
		break;
	case 4:
		writel(readl(pmydev->pled4_dat)|(0x1<<4),pmydev->pled4_dat);	
		break;
	case 5:
		writel(readl(pmydev->pled5_dat)|(0x1<<5),pmydev->pled5_dat);
		break;

	}
}

void led_off(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		writel(readl(pmydev->pled2_dat)&(~(0x1<<7)),pmydev->pled2_dat);		
		break;
	case 3:
		writel(readl(pmydev->pled3_dat)&(0x1),pmydev->pled3_dat);
		break;
	case 4:
		writel(readl(pmydev->pled4_dat)&(~(0x1<<4)),pmydev->pled4_dat);	
		break;
	case 5:
		writel(readl(pmydev->pled5_dat)&(~(0x1<<5)),pmydev->pled5_dat);
		break;
	}

}
long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned int arg)
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;

	
		switch (cmd)
		{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
			led_off(pmydev,arg);
			break;	
		default:
			return -1;
		}

}



struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myled_open,
	.release = myled_close,
	.unlocked_ioctl= myled_ioctl,
};
void ioremap_ledreg(struct myled_dev *pmydev,struct platform_device *p_pltdev)
{
	struct resource *pre=NULL;

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,2);
	pmydev->pled2_con=ioremap(pre->start,4);

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,3);
	pmydev->pled2_dat=ioremap(pre->start,4);
	

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,0);
	pmydev->pled3_con=ioremap(pre->start,4);

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,1);
	pmydev->pled3_dat=ioremap(pre->start,4);

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,4);
	pmydev->pled4_con=ioremap(pre->start,4);

	pre=platform_get_resource(p_pltdev,IORESOURCE_MEM,5);
	pmydev->pled4_dat=ioremap(pre->start,4);

	pmydev->pled5_con=pmydev->pled4_con;
	pmydev->pled5_dat=pmydev->pled4_dat;

}
void set_output_ledconreg(struct myled_dev *pmydev)
{
	writel((readl(pmydev->pled2_con)&(~(0xf<<28)))|(0x1<<28),pmydev->pled2_con);		
	writel((readl(pmydev->pled3_con)&(~(0xf)))|(0x1),pmydev->pled3_con);
	writel((readl(pmydev->pled4_con)&(~(0xf<<16)))|(0x1<<16),pmydev->pled4_con);
	writel((readl(pmydev->pled5_con)&(~(0xf<<20)))|(0x1<<20),pmydev->pled5_con);

	writel(readl(pmydev->pled2_dat)&(~(0x1<<7)),pmydev->pled2_dat);		
	writel(readl(pmydev->pled3_dat)&(0x1),pmydev->pled3_dat);
	writel(readl(pmydev->pled4_dat)&(~(0x1<<4)),pmydev->pled4_dat);
	writel(readl(pmydev->pled5_dat)&(~(0x1<<5)),pmydev->pled5_dat);
}
void iounmap_ledreg(struct myled_dev *pmydev)
{
	iounmap(pmydev->pled2_con);
	pmydev->pled2_con = NULL;
	iounmap(pmydev->pled2_dat);
	pmydev->pled2_dat = NULL;

	iounmap(pmydev->pled3_con);
	pmydev->pled3_con = NULL;
	iounmap(pmydev->pled3_dat);
	pmydev->pled3_dat = NULL;

	iounmap(pmydev->pled4_con);
	pmydev->pled4_con = NULL;
	iounmap(pmydev->pled4_dat);
	pmydev->pled4_dat = NULL;

	pmydev->pled5_con = NULL;
	pmydev->pled5_dat = NULL;
}



int fs4412leds_driver_probe(struct platform_device* p_pltdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	//int i = 0;

	/*申请设备号*/
	ret = register_chrdev_region(devno,myled_num,"myled");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//容易遗漏，注意
	}

	pgmydev=(struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);
	if(pgmydev==NULL)
	{
		unregister_chrdev_region(devno,myled_num);
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));

	/*给struct cdev对象指定操作函数集*/	
	cdev_init(&pgmydev->mydev,&myops);

	/*将struct cdev对象添加到内核对应的数据结构里*/
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,1);

	//ioremap
	ioremap_ledreg(pgmydev,p_pltdev);

	//con_register set output//
    set_output_ledconreg(pgmydev);
	return 0;
}
int fs4412leds_driver_remove(struct platform_device* p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
	//int i = 0;

	cdev_del(&pgmydev->mydev);
 	iounmap_ledreg(pgmydev);

	unregister_chrdev_region(devno,myled_num);

	kfree(pgmydev);
	pgmydev=NULL;
	return 0;

}

struct platform_driver fs4412leds_driver=
{
	.driver.name="fs4412leds",
	.probe=fs4412leds_driver_probe,
	.remove=fs4412leds_driver_remove,

};

int __init fs4412leds_driver_init(void)
{
	platform_driver_register(&fs4412leds_driver);
	return 0;
}
void __exit fs4412leds_driver_exit(void)
{
	platform_driver_unregister(&fs4412leds_driver);
}
	
MODULE_LICENSE("GPL");

module_init(fs4412leds_driver_init);
module_exit(fs4412leds_driver_exit);

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

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

相关文章

sadtalker学习用于风格化音频驱动单图像说话人脸动画的真实 3D 运动系数的应用

sadtalker学习用于风格化音频驱动单图像说话人脸动画的真实 3D 运动系数的应用

论文出处 https://arxiv.org/abs/2211.12194 使用方法 1. 打开项目的colab链接 https://colab.research.google.com/github/Winfredy/SadTalker/blob/main/quick_demo.ipynb#scrollTofAjwGmKKYl_I 在examples/source_image文件夹中添加希望动起来说话的图片&#xff0c;这…
阅读更多...
厦门攸信技术亮相新技术研讨会，展现物流自动化解决方案新高度！

厦门攸信技术亮相新技术研讨会，展现物流自动化解决方案新高度！

今日&#xff0c;厦门攸信信息技术有限公司受邀参加了一场备受行业关注的电子制造高端盛会——一步步新技术研讨会&#xff0c;凭借卓越的智能制造与物流自动化技术在会议中大放异彩。作为一家引领行业发展的企业&#xff0c;厦门攸信技术不仅展示了其深厚的技术底蕴&#xff0…
阅读更多...
java全排列（力扣Leetcode46）

java全排列（力扣Leetcode46）

全排列 力扣原题链接 问题描述 给定一个不含重复数字的数组 nums&#xff0c;返回其所有可能的全排列。你可以按任意顺序返回答案。 示例 示例 1&#xff1a; 输入&#xff1a;nums [1,2,3] 输出&#xff1a;[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 示例 2…
阅读更多...
路径规划——搜索算法详解（二）：Floyd算法详解与MATLAB代码

路径规划——搜索算法详解（二）：Floyd算法详解与MATLAB代码

上次总结了Dijkstra算法的案例原理与代码&#xff0c;本文分享第二种比较基础且易懂的方法为Floyd算法&#xff0c;该算法可以有效正确地处理有向图的最短路径问题&#xff0c;与Dijkstra算法不同&#xff0c;Floyd算法是一种动态规划算法&#xff0c;对于稠密图效果显著。原理…
阅读更多...
从易到难，推荐9个适合练手的C++项目

从易到难，推荐9个适合练手的C++项目

老有一些同学和我说学习了 C 以后&#xff0c;想要做些项目锻炼自己&#xff0c;让我从「简单到难」都推荐一些。 那有啥说的&#xff0c;必须推荐&#xff01;毕竟 C 的优质项目我见过太多了&#xff01; 下面我就按照「从易到难」的梯度&#xff0c;依次来推荐&#xff0c;…
阅读更多...
你真的会数据结构吗：二叉树

你真的会数据结构吗：二叉树

❀❀❀ 文章由不准备秃的大伟原创 ❀❀❀ ♪♪♪ 若有转载&#xff0c;请联系博主哦~ ♪♪♪ ❤❤❤ 致力学好编程的宝藏博主&#xff0c;代码兴国&#xff01;❤❤❤ halo铁汁们&#xff0c;没错又是你们人见人爱&#xff0c;花见花开的大伟啊&#xff0c;今天也是周六&#x…
阅读更多...
JHY-31复合电压继电器 额定电压Un=110VDC 板后接线 JOSEF约瑟

JHY-31复合电压继电器 额定电压Un=110VDC 板后接线 JOSEF约瑟

用途&#xff1a; JHY-31复合电压继电器使用于电力系统的继电保护线路中&#xff0c;作为各种类型故障的判别元件和电压闭锁元件。 继电器型号名称&#xff1a; 例:辅助直流工作电压为110V的复合电压继电器的订货代号为: JHY-31/110V。 工作原理&#xff1a; 继电器内部具有负…
阅读更多...
OpenFeign 基本介绍

OpenFeign 基本介绍

OpenFeign能干什么 前面在使用SpringCloud LoadBalancerRestTemplate时&#xff0c;利用RestTemplate对http请求的封装处理形成了一套模版化的调用方法。但是在实际开发中&#xff0c; 由于对服务依赖的调用可能不止一处&#xff0c;往往一个接口会被多处调用&#xff0c;所以…
阅读更多...
浏览器工作原理与实践--垃圾回收：垃圾数据是如何自动回收的

浏览器工作原理与实践--垃圾回收：垃圾数据是如何自动回收的

在上一篇文章中&#xff0c;我们提到了JavaScript中的数据是如何存储的&#xff0c;并通过例子分析了原始数据类型是存储在栈空间中的&#xff0c;引用类型的数据是存储在堆空间中的。通过这种分配方式&#xff0c;我们解决了数据的内存分配的问题。 不过有些数据被使用之后&am…
阅读更多...
Codeforces Round 850 (Div. 2) D. Letter Exchange

Codeforces Round 850 (Div. 2) D. Letter Exchange

题目 思路&#xff1a; #include <bits/stdc.h> using namespace std; #define int long long #define pb push_back #define fi first #define se second #define lson p << 1 #define rson p << 1 | 1 const int maxn 1e6 5, inf 1e9, maxm 4e4 5; co…
阅读更多...
拥抱挑战，开启增长：2024年全球产品团队的OKR策略

拥抱挑战，开启增长：2024年全球产品团队的OKR策略

2024年&#xff0c;全球经济格局进入重塑阶段。消费者在消费选择上趋于严苛&#xff0c;企业需推出更具吸引力的产品与服务&#xff0c;以赢得消费者的青睐。同时&#xff0c;企业需通过持续创新&#xff0c;提升产品竞争力&#xff0c;方能在充满挑战的市场环境中实现持续增长…
阅读更多...
node.js学习（2）

node.js学习（2）

版权声明 以下文章为尚硅谷PDF资料&#xff0c;B站视频链接&#xff1a;【尚硅谷Node.js零基础视频教程&#xff0c;nodejs新手到高手】仅供个人学习交流使用。如涉及侵权问题&#xff0c;请立即与本人联系&#xff0c;本人将积极配合删除相关内容。感谢理解和支持&#xff0c;…
阅读更多...
Jmeter 从登录接口提取cookie 并 跨线程组调用cookie （超详细）

Jmeter 从登录接口提取cookie 并 跨线程组调用cookie （超详细）

文章目录 一、开始前的准备二、 业务场景介绍三、从登录接口提取cookies四、跨线程组调用cookies 一、开始前的准备 1、安装Jmeter&#xff0c;参考文章&#xff1a;JMeter 3.1 和JMeterPlugin的下载安装 2、设置配置文件使Cookie管理器保存cookie信息。 修改apache-jmeter-x…
阅读更多...
DAY16 二叉树最大深度最小深度完全二叉树节点个数

DAY16 二叉树最大深度最小深度完全二叉树节点个数

9.二叉树的最大深度 递归法 后序遍历 本题可以使用前序&#xff08;中左右&#xff09;&#xff0c;也可以使用后序遍历&#xff08;左右中&#xff09;&#xff0c;使用前序求的就是深度&#xff0c;使用后序求的是高度。 二叉树节点的深度&#xff1a;指从根节点到该节点…
阅读更多...
安装和使用 Oracle Database 23c 容器鏡像

安装和使用 Oracle Database 23c 容器鏡像

Oracle Database 23c 是 Oracle 最新的数据库版本&#xff0c;它带来了许多新特性和性能改进。 对于开发者来说&#xff0c;Oracle 提供了一个免费的开发者版&#xff0c; 可以通过 Docker 容器轻松安装和使用。以下是详细的安装和使用指南。 安装 Docker 在开始之前&#xff0…
阅读更多...
FME学习之旅---day17

FME学习之旅---day17

我们付出一些成本&#xff0c;时间的或者其他&#xff0c;最终总能收获一些什么。 【FME-HOW-TO系列】28 栅格邻域函数 RasterConvolver转换器说明&#xff1a; 接受包含栅格几何对象的输入要素&#xff0c;并在对所有波段应用卷积滤波 器后输出要素。 本人对栅格数据处理的较…
阅读更多...
npm mongoose包下载冲突解决之道

npm mongoose包下载冲突解决之道

我在新电脑下载完项目代码后,运行 npm install --registryhttps://registry.npm.taobao.org 1运行就报错&#xff1a; npm ERR! code ERESOLVE npm ERR! ERESOLVE unable to resolve dependency tree npm ERR! npm ERR! While resolving: lowcode-form-backend1.0.0 npm …
阅读更多...
Find Any File (FAF) for Mac：您的专属文件搜索神器

Find Any File (FAF) for Mac：您的专属文件搜索神器

在数字时代&#xff0c;我们的Mac硬盘中堆积着各式各样的文件&#xff0c;从工作文档到家庭照片&#xff0c;从音乐视频到学习资料&#xff0c;无一不体现出我们的生活和工作的丰富多彩。然而&#xff0c;当我们需要快速找到某个特定文件时&#xff0c;却常常在茫茫文件海中迷失…
阅读更多...
送朋友的生日祝福静态页面代码！（小白也能轻松GET！）

送朋友的生日祝福静态页面代码！（小白也能轻松GET！）

Hey亲爱的小白们&#xff01;&#x1f44b; 知道你们想给朋友一个独特又有心的生日祝福&#xff0c;却苦于没有编程基础吗&#xff1f;别担心&#xff0c;来白嫖&#xff01;&#x1f381; &#x1f680;【生日祝福静态页面代码】来啦&#xff01;只需简单几步&#xff0c;就能…
阅读更多...
Redis 的慢日志

Redis 的慢日志

Redis 的慢日志 Redis 的慢日志&#xff08;Slow Log&#xff09;是用于记录执行时间超过预设阈值的命令请求的系统。慢日志可以帮助运维人员和开发人员识别潜在的性能瓶颈&#xff0c;定位那些可能导致 Redis 性能下降或响应延迟的慢查询。以下是 Redis 慢日志的相关细节&…
阅读更多...
最新文章

Copyright @ 2022~2023