基于框架的平台总线式开发

news2024/10/2 10:33:40

一、总线、设备、驱动

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

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

```c

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

```c

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对象地址) 重要

    //......

};

```
```c

struct of_device_id

{

    char name[32];//设备名

    char type[32];//设备类型

    char compatible[128]; //用于device和driver的match，重点

};

//用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

```

三、platform总线驱动

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

基本结构图：

3.1 核心数据类型之platform_device

```c

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;//设备八字

};

```
```c

struct platform_device_id

{

    char name[20];//匹配用名称

    kernel_ulong_t driver_data;//需要向驱动传输的其它数据

};

```
```c

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使用的中断号的开始地址和结束值

*/

```
```c

/**

 *注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe；

 */

int platform_device_register(struct platform_device *);

/**

 *注销：把指定设备从设备列表中删除，如果驱动已匹配则回调驱动方法和设备信息中的release；

 */

void platform_device_unregister(struct platform_device *);

```
```c

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

```c

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;  //能够支持的设备八字数组，用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

};

```
```c

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成员必须设置

五、名称匹配之基础框架


```c

/*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");

```


```c

/*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");



```

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

 

//driver
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>

int hello_driver_probe(struct platform_device *p_pltdev)
{
	struct resource *pres = NULL;
	printk("hellio_driver_probe is called\n");
	return 0;
}

int hello_driver_remove(struct platform_device *p_pltdev)
{
	printk("hellio_driver_remove is called\n");
	return 0;
}

struct platform_driver hello_driver =
{
	.driver.name = "hello",
	.probe = hello_driver_probe,
	.remove = hello_driver_remove,
};

int __init hello_driver_init(void)
{
	platform_driver_register(&hello_driver);
	return 0;
}
void __exit hello_driver_exit(void)
{
	platform_driver_unregister(&hello_driver);
}
MODULE_LICENSE("GPL");
module_init(hello_driver_init);
module_exit(hello_driver_exit);

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>

static void hello_device_release(struct device *dev)
{
	printk("platform:device release\n");
}

struct resource hello_dev_res [] =
{
	[0] = {.start = 0x1000, .end=0x1003, .name="reg1", .flags = IORESOURCE_MEM},
	[1] = {.start = 0x2000, .end=0x2003, .name="reg2", .flags = IORESOURCE_MEM},
	[2] = {.start = 10, .end=10, .name="irq1", .flags = IORESOURCE_IRQ},
	[3] = {.start = 0x3000, .end=0x3003, .name="reg3", .flags = IORESOURCE_MEM},
	[4] = {.start = 100, .end=100, .name="irq2", .flags = IORESOURCE_IRQ},
	[5] = {.start = 62, .end=62, .name="irq3", .flags = IORESOURCE_IRQ},
};

struct platform_device hello_device =
{
	.id = -1,
	.name = "hello",
	.dev.release = hello_device_release,
	.resource = hello_dev_res,
	.num_resources = ARRAY_SIZE(hello_dev_res),
};

int __init hello_device_init(void)
{
	platform_device_register(&hello_device);
	return 0;
}
void __exit hello_device_exit(void)
{
	platform_device_unregister(&hello_device);
}
MODULE_LICENSE("GPL");
module_init(hello_device_init);
module_exit(hello_device_exit);


//driver
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>

int hello_driver_probe(struct platform_device *p_pltdev)
{
	struct resource *pres = NULL;
	printk("hellio_driver_probe is called\n");
	
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);
	printk("res.start = 0x%x\n",(unsigned int)pres->start);
	
	pres = platform_get_resource(p_pltdev,IORESOURCE_IRQ,1);
	printk("res.start = %d\n",(int)pres->start);
	return 0;
}

int hello_driver_remove(struct platform_device *p_pltdev)
{
	printk("hellio_driver_remove is called\n");
	return 0;
}

struct platform_driver hello_driver =
{
	.driver.name = "hello",
	.probe = hello_driver_probe,
	.remove = hello_driver_remove,
};

int __init hello_driver_init(void)
{
	platform_driver_register(&hello_driver);
	return 0;
}
void __exit hello_driver_exit(void)
{
	platform_driver_unregister(&hello_driver);
}
MODULE_LICENSE("GPL");
module_init(hello_driver_init);
module_exit(hello_driver_exit);

 

六、名称匹配之led实例

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

#include "leddrv.h"



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)
{
	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 long arg)
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;

	if(arg < 2 || arg > 5)
	{
		return -1;
	}
	switch(cmd)
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
			led_off(pmydev,arg);
			break;
		default:
			return -1;
	}

	return 0;
}

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 *pres = NULL;


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

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


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

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

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

	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,5);
	pmydev->pled4_dat = ioremap(pres->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);

	/*申请设备号*/
	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(NULL == pgmydev)
	{
		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,myled_num);

	/*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);

	/*iounmap*/
	iounmap_ledreg(pgmydev);

	cdev_del(&pgmydev->mydev);

	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);

 

#include <linux/module.h>
#include <linux/kernel.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_dev_release(struct device *pdev)
{
	printk("fs4412leds_dev_release is called\n");
}

struct resource fs4412leds_dev_res [] =
{
	[0] = {.start = GPX1CON,.end=GPX1CON + 3,.name="GPX1CON",.flags = IORESOURCE_MEM},
	[1] = {.start = GPX1DAT,.end=GPX1DAT + 3,.name="GPX1DAT",.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_dev_release,
	.resource = fs4412leds_dev_res,
	.num_resources = ARRAY_SIZE(fs4412leds_dev_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);

#ifndef LED_DRIVER_H
#define LED_DRIVER_H

#define LED_DEV_MAGIC 'g'

#define MY_LED_OFF _IO(LED_DEV_MAGIC,0)
#define MY_LED_ON _IO(LED_DEV_MAGIC,1)



#endif

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Telnet 基础实验2： SSH 实验

Telnet 基础实验2： SSH 实验

Telnet 基础实验2&#xff1a; SSH 实验 本实验只能使用 eNSP中 AR 系统的路由器做 拓扑图 SSH &#xff1a; Secure Shell 是一个网络安全协议&#xff0c;基本于 TCP 协议 22 端口传输数据&#xff0c;通过对网络数据的加密&#xff0c;使其能够在一个不安全的网络环境中&a…
阅读更多...
网易新财报：游戏养家，教育维稳、音乐快走

网易新财报：游戏养家，教育维稳、音乐快走

配图来自Canva可画 随着互联网流量红利逐渐消退&#xff0c;互联网大厂们也告别高增长时代&#xff0c;逐渐进入稳定增长阶段。近两年&#xff0c;流量焦虑、业务失速等问题更是成为了一团浓雾&#xff0c;笼罩在互联网大厂周围。不过&#xff0c;面对所遭遇的难题&#xff0c…
阅读更多...
力扣-换座位

力扣-换座位

大家好&#xff0c;我是空空star&#xff0c;本篇带大家了解一道简单的力扣sql练习题。 文章目录前言一、题目&#xff1a;626. 换座位二、解题1.正确示范①提交SQL运行结果2.正确示范②提交SQL运行结果3.正确示范③提交SQL运行结果4.正确示范④提交SQL运行结果5.其他总结前言 …
阅读更多...
读书笔记——《富爸爸穷爸爸》

读书笔记——《富爸爸穷爸爸》

《富爸爸穷爸爸》&#xff0c;以前不屑读这种书。这种书就是那种走进书店放在门口展销位的成功学著作&#xff0c;一眼看上去没什么实在的内容&#xff0c;看上去很不靠谱&#xff0c;感觉就是骗一些社会底层又做着暴富梦的人来买的&#xff0c;但是由于自身原因或环境局限根本…
阅读更多...
Spring Boot + Vue3 前后端分离 实战 wiki 知识库系统＜二＞---后端架构完善与接口开发

Spring Boot + Vue3 前后端分离 实战 wiki 知识库系统＜二＞---后端架构完善与接口开发

数据库准备&#xff1a; 在上一次Spring Boot Vue3 前后端分离 实战 wiki 知识库系统<一>---Spring Boot项目搭建已经将SpringBoot相关的配置环境给搭建好了&#xff0c;接下来则需要为咱们的项目创建一个数据库。 1、mysql的安装&#xff1a; 关于mysql的安装这里就…
阅读更多...
【C语言每日一题】杨氏矩阵（源码以及改进源码）

【C语言每日一题】杨氏矩阵（源码以及改进源码）

【C语言每日一题】—— 杨氏矩阵&#x1f60e;&#x1f60e;&#x1f60e; 目录 &#x1f4a1;前言&#x1f31e;&#xff1a; &#x1f49b;杨氏矩阵题目&#x1f49b; &#x1f4aa; 解题思路的分享&#x1f4aa; &#x1f60a;题目源码的分享&#x1f60a; &#x1f4…
阅读更多...
夜天之书 #73 Apache Pulsar 的社群指标

夜天之书 #73 Apache Pulsar 的社群指标

去年十一月&#xff0c;我成为了 Apache Pulsar[1] 社群 Committers 的一员。成为 Committer 之前和之后&#xff0c;我都积极参与了代码仓库上 Issue 和 Pull Request (PR) 的处理回应和评审。去年十二月期间&#xff0c;我把未解决的 Issue 和 PR 数量分别从接近 2000 个和 4…
阅读更多...
STM32学习笔记-I2C通信协议

STM32学习笔记-I2C通信协议

文章目录介绍&#xff1a;两种实现方式&#xff1a;I2C设备的常用连接方式&#xff1a;I2C协议时序&#xff1a;STM32硬件I2C框架图I2C外设通讯过程**I2C读写EEPROM**&#xff08;硬件I2C&#xff09;介绍&#xff1a; 两根通信线SCL&#xff08;时钟线&#xff09;、SDA&#…
阅读更多...
C语言中的强制类型转换

C语言中的强制类型转换

强制类型转换是把变量从一种类型转换为另一种数据类型。例如&#xff0c;如果您想存储一个 long 类型的值到一个简单的整型中&#xff0c;您需要把 long 类型强制转换为 int 类型。您可以使用强制类型转换运算符来把值显式地从一种类型转换为另一种类型&#xff0c;如下所示&am…
阅读更多...
“ChatGPT之父”Sam Altman：如何成功？

“ChatGPT之父”Sam Altman：如何成功？

背靠微软&#xff0c;OpenAI能拳打谷歌&#xff0c;脚踢Meta&#xff0c;它背后的男人&#xff0c;必然不简单。 让我们来看一看&#xff0c;Sam Altman是如何一步步成长为今天这个搅动全世界的男人。 山姆奥特曼&#xff08;Sam Altman&#xff09; 成长和创业经历 在YC创始…
阅读更多...
代码随想录【Day27】| 39. 组合总和、40. 组合总和 II、131. 分割回文串

代码随想录【Day27】| 39. 组合总和、40. 组合总和 II、131. 分割回文串

39. 组合总和 题目链接 题目描述&#xff1a; 给定一个无重复元素的数组 candidates 和一个目标数 target &#xff0c;找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明&#xff1a; 所有数字&#xff08;包括 tar…
阅读更多...
JavaScript 高级2 ：构造函数和原型 d331702016e84f54b3594ae05e0eeac

JavaScript 高级2 ：构造函数和原型 d331702016e84f54b3594ae05e0eeac

JavaScript 高级2 &#xff1a;构造函数和原型 Date: January 16, 2023 Text: 构造函数和原型、继承、ES5中的新增方法 目标 能够使用构造函数创建对象 能够说出原型的作用 能够说出访问对象成员的规则 能够使用 ES5新增的一些方法 构造函数和原型 概述 在典型的 OOP 的…
阅读更多...
MySQL之EXPLAIN

MySQL之EXPLAIN

使用方法 查询结果分析 id&#xff1a;识别符 select_type&#xff1a;表示查询的类型 table&#xff1a;输出结果集的表 partitions&#xff1a;匹配的分区 type&#xff1a;表示表的连接类型 possible_keys&#xff1a;表示查询时&#xff0c;可能使用的索引 key&#xff1a…
阅读更多...
jni-Demo-基于linux（c++ java）

jni-Demo-基于linux（c++ java）

跑一个jni 的最简单的Demo需要提前准备 VsCode 编译器、win10下&#xff0c;vscode中集成linux操作系统、c编译器&#xff08;gcc、g&#xff09;&#xff0c;java编译器&#xff08;jdk1.8&#xff09;参考&#xff1a;https://mangocool.com/1653030123842.htmlJniDemo类&…
阅读更多...
【分享】灌溉制度设计小程序VB源代码

【分享】灌溉制度设计小程序VB源代码

说明 根据作物需水特性和当地气候、土壤、农业技术及灌水技术等因素制定的灌水方案。主要内容包括灌水次数、灌水时间、灌水定额和灌溉定额。灌溉制度是规划、设计灌溉工程和进行灌区运行管理的基本资料&#xff0c;是编制和执行灌区用水计划的重要依据。 1—计划湿润土层允…
阅读更多...
spring面试题总结

spring面试题总结

1、spring是什么&#xff1f; spring是一个轻量级IOC和AOP容器框架&#xff0c;是为Java应用程序提供基础性服务的一套框架&#xff0c;目的是用于简化企业应用的开发&#xff0c;开发者只需要关注业务需求即可&#xff1a; core container 容器组件 spring context&#xff0c…
阅读更多...
@ConfigurationProperties在方法上的使用

@ConfigurationProperties在方法上的使用

文章目录1. 前言2. 先说结论3. 代码解释1. Component ConfigurationProperties2. EnableConfigurationProperties ConfigurationProperties3. Bean ConfigurationProperties1. 前言 在学习spring的时候&#xff0c;ConfigurationProperties应该经常被使用到&#xff0c;作用…
阅读更多...
一文弄清混合云架构模式

一文弄清混合云架构模式

当我们在说云架构的时候&#xff0c;通常指的并不是云平台的自身架构&#xff0c;而是基于云平台的软件系统基础架构。云平台的自身架构满足了很多通用层面的需求&#xff0c;例如对象存储&#xff0c;弹性主机&#xff0c;虚拟网络等等&#xff0c;只有云服务厂商的工程师才会…
阅读更多...
Win10系统内置杀毒软件Windows Defender卸载方法

Win10系统内置杀毒软件Windows Defender卸载方法

Windows10系统自带的Windows Defender杀毒软件&#xff0c;偶尔会使你的电脑CPU满负荷运载。 其实我们完全可以删除这个Windows10自带的杀毒软件&#xff0c;我们忍耐总是有限度的&#xff0c;所以&#xff0c;你可以选择删除它&#xff1b; 怎么删除呢&#xff1f;下面有个方…
阅读更多...
Pthon--自动化实用技巧篇--文件目录处理

Pthon--自动化实用技巧篇--文件目录处理

为什么要讲这一篇&#xff0c;主要是因为这个在自动化测试框架或者脚本的编写的时候会用到&#xff0c;还是比较方便的。看上述两个函数。getcwd()、chdir()。使用 os.getcwd() 函数获得当前工作目录。使用 os.chdir()函数改变当前工作目录。所以在用chdir()函数的时候别忘记指…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023