平台总线式驱动开发——基本框架

news2024/12/24 21:16:32

1. 总线、设备和驱动

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

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

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

在这里插入图片描述
struct device来表示一个具体设备，主要提供具体设备相关的资源（如寄存器地址、GPIO、中断等）
struct device_driver来表示一个设备驱动，一个驱动可以支持多个操作逻辑相同的设备

由此产生的问题————怎样将两者进行关联（匹配）？
硬件上同一总线上的设备遵循一致的时序通信，在其基础上增加管理设备和驱动的软件功能，于是引入总线（BUS），各种总线的核心框架有内核来实现，通信时序一般由SOC供应商支持；
内核中用struct bus_type 来表示一种总线，总线可以是实际存在的总线，也可以是虚拟总线：

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

理解方式：
设备：提供硬件资源——男
驱动：提供驱动代码——女
总线：匹配设备和驱动——婚介所：提供沟通机制，完成拉郎配

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

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

1.2.3 基本数据类型

  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);//删除设备，重要
    //.......
}；
  1. 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，重点
};
//用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

2. 平台总线基础框架

2.1 platform总线驱动

platform是一种虚拟总线，主要用来管理那些不需要时序通信的设备
基本结构图：
在这里插入图片描述

2.2 核心数据类型之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
*/

2.3 核心数据类型之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);

3. platform的三种匹配方式

在这里插入图片描述
3.1 名称匹配：一个驱动只对应一个设备 ----- 优先级最低

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

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

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

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

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

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

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

3.1 名称匹配基础框架

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

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

3.2 ID匹配基础框架

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

注意事项：

  1. device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，struct platform_device中的name成员必须指定
  2. driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中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_id test_id = {
    .name = "test_device",
};

struct platform_device test_device = {
	.name = "test_device",//必须初始化
	.dev.release = device_release, 
    .id_entry = &test_id,
};

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_device_id testdrv_ids[] = 
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
	},
    .id_table = testdrv_ids,
};

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

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

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

3.3 设备树匹配基础框架

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

注意事项：

  1. 无需编写device模块，只需编写driver模块
  2. 使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符
  3. id_table可不设置，但struct platform_driver成员driver的name成员必须设置
/*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_device_id testdrv_ids[] = 
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct of_device_id test_of_ids[] = 
{
	[0] = {.compatible = "xyz,abc"},
    [1] = {.compatible = "qwe,opq"},
    [2] = {},
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
        .of_match_table = test_of_ids,
	},
};

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

4.（名称匹配）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/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include "leddrv.h"

int major = 11;
int minor = 0;
int leddrv_num = 1;

struct leddrv_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 class *pcls;
	struct device *pdev;
};

struct leddrv_dev *pgmydev;

int leddrv_open(struct inode *pnode,struct file *pfile);
int leddrv_close(struct inode *pnode,struct file *pfile);
long leddrv_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg);
void ioremap_ledreg(struct leddrv_dev *pmydev,struct platform_device *p_pltdev);
void set_out_ledreg(struct leddrv_dev *pmydev);
void iounmap_ledreg(struct leddrv_dev *pmydev);
void led_on(struct leddrv_dev *pmydev,int ledno);
void led_off(struct leddrv_dev *pmydev,int ledno);

struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = leddrv_open,
	.release = leddrv_close,
	.unlocked_ioctl = leddrv_ioctl,
};

int fs4412leds_driver_probe(struct platform_device *p_pltdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	
	ret = register_chrdev_region(devno,leddrv_num,"leddrv");
	if(ret){
		ret = alloc_chrdev_region(&devno,minor,leddrv_num,"leddrv");
		if(ret){
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);
	}
	
	pgmydev = (struct leddrv_dev *)kmalloc(sizeof(struct leddrv_dev),GFP_KERNEL);
	if(NULL == pgmydev){
		unregister_chrdev_region(devno,leddrv_num);
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct leddrv_dev));
	cdev_init(&pgmydev->mydev,&myops);

	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,leddrv_num);
	
	/*ioremap*/
	ioremap_ledreg(pgmydev,p_pltdev);
	/*con_register set output*/
	set_out_ledreg(pgmydev);

	pgmydev->pcls = class_create(THIS_MODULE,"myled");
	if(IS_ERR(pgmydev->pcls)){
		printk("class_create failed\n");
		cdev_del(&pgmydev->mydev);
		unregister_chrdev_region(devno,leddrv_num);
		kfree(pgmydev);
		pgmydev = NULL;
		return -1;
	}
	pgmydev->pdev = device_create(pgmydev->pcls,NULL,devno,NULL,"leddrv");
	if(NULL == pgmydev->pdev){
		printk("class_create failed\n");
		class_destroy(pgmydev->pcls);
		cdev_del(&pgmydev->mydev);
		unregister_chrdev_region(devno,leddrv_num);
		kfree(pgmydev);
		pgmydev = NULL;
		return -1;
	}

	return 0;
}

int fs4412leds_driver_remove(struct platform_device *p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
	/*iounmap*/

	iounmap_ledreg(pgmydev);
	class_destroy(pgmydev->pcls);
	device_destroy(pgmydev->pcls,devno);

	cdev_del(&pgmydev->mydev);
	unregister_chrdev_region(devno,leddrv_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);
}


int leddrv_open(struct inode *pnode,struct file *pfile)
{
	pfile->private_data = (void *)container_of(pnode->i_cdev,struct leddrv_dev,mydev);
	return 0;
}


int leddrv_close(struct inode *pnode,struct file *pfile)
{
	return 0;
}

void led_on(struct leddrv_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 << 0),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 leddrv_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 << 0)),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 leddrv_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
	struct leddrv_dev  *pmydev = (struct leddrv_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;
}

void ioremap_ledreg(struct leddrv_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_out_ledreg(struct leddrv_dev *pmydev)
{
	writel(((readl(pmydev->pled2_con) & (~(0xf << 28))) | (0x1 << 28)),pmydev->pled2_con);
	writel(((readl(pmydev->pled3_con) & (~(0xf <<  0))) | (0x1 <<  0)),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 << 0)),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 leddrv_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;
}




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

5.宏替代（驱动中常用）

struct platform_driver xxx = {
…
};
module_platform_driver(xxx);
//最终展开后就是如下形式：
static int __init xxx_init(void)
{
return platform_driver_register(&xxx);
}
module_init(xxx_init);
static void __exit xxx_init(void)
{
return platform_driver_unregister(&xxx);
}
module_exit(xxx_exit)

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

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

相关文章

ES为什么要移除types类型

ES为什么要移除types类型

文章目录elasticsearch&#xff08;集群&#xff09;中可以包含多个索引index&#xff08;数据库&#xff09; ,每个索引中可以包含多个类型types&#xff08;表&#xff09; ,每个类型下又包含多个文档Document&#xff08;行&#xff09; ,每个文档中又包含多个字段Field&…
阅读更多...
姿态估计评价指标

姿态估计评价指标

PCK 正确估计出关键点的百分比 &#xff08;Percentage of Correct Keypoints&#xff09;&#xff0c;现在已基本不用。 PCKik∑iδ(did≤Tk)∑i1PCK_i^k\frac{\sum_i\delta(\frac{d_i}{d}\leq T_k)}{\sum_i1} PCKik​∑i​1∑i​δ(ddi​​≤Tk​)​ 检测出的关键点与其对应…
阅读更多...
1 机器学习之线性回归

1 机器学习之线性回归

学习笔记自&#xff0c;慕课网 《Python3 入门人工智能》 https://coding.imooc.com/lesson/418.html#mid33109 麻雀虽小&#xff0c;五脏俱全 1.1 回归分析 1.2 线性回归问题求解 1.3 寻找最合适的 a、b&#xff0c;引入损失函数的概念 尽可能使损失函数最小即找到了最合适的…
阅读更多...
(重要)实数域上一切范数等价的证明

(重要)实数域上一切范数等价的证明

证明&#xff1a;实数域上一切范数等价编辑切换为居中添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09;首先需要明确范数等价的条件&#xff0c;这里的条件等价于夹逼&#xff0c;就是A小于等于B&#xff0c;B小于等于A&#xff0c;那么A肯定等于B。利用这个…
阅读更多...
【MySQL】InnoDB存储引擎的行结构

【MySQL】InnoDB存储引擎的行结构

文章目录前言1、MySQL的体系结构2、InnoDB逻辑存储结构3、InnoDB记录行结构3.1、概述3.2、语法操作3.3、Compact行格式3.3.1、示意图3.3.2、记录的额外信息3.3.3、记录的真实数据3.3.4、定长字段补充3.4、行溢出前言 MySQL服务器上负责对表中数据的读取和写入工作的部分是存储…
阅读更多...
【博学谷学习记录超强总结，用心分享|产品经理基础总结和感悟14】

【博学谷学习记录超强总结，用心分享|产品经理基础总结和感悟14】

TOC 第三章&#xff0c; 内容服务平台优化思考 前文中&#xff0c;我们粗略分析了用户阅读内容的诉求和创作者编制内容的诉求&#xff0c;本章笔者尝试结合用户诉求分析平台的内容分发策略&#xff0c;结合创作者诉求分析创作者后台设计思路&#xff0c;创作者后台分析主要从…
阅读更多...
Java实现支付宝支付，内网穿透，支付功能实现-57

Java实现支付宝支付，内网穿透，支付功能实现-57

一&#xff1a;支付业务 1.1 支付宝业务简介 1&#xff09;网页跳转到支付宝收银台页面。用户可以使用支付宝App扫一扫屏幕二维码&#xff0c;待手机提示付款后选择支付工具输入密码即可完成支付&#xff1b; 2&#xff09;如果不使用手机支付&#xff0c;也可以点击上图右侧…
阅读更多...
Visual Studio解决方案中添加src文件夹的方法

Visual Studio解决方案中添加src文件夹的方法

如标题&#xff0c;这个听起来是一个愚蠢的问题&#xff0c;但如果在Visual Studio想添加一个src文件夹&#xff0c;而命名空间不包含src的话&#xff0c;似乎还真不容易。 如果在Visual Studio里新建一个空白解决方案&#xff0c;然后右键解决方案->添加->新建解决方案…
阅读更多...
鲲鹏BigData Pro解决方案中Hive组件的部署

鲲鹏BigData Pro解决方案中Hive组件的部署

1 介绍 本博文基于《鲲鹏Bigdata pro之Hive集群部署》的实验手册进行&#xff0c;目的是方便Hive学习者重用&#xff08;从本文复制&#xff09;相关的指令、配置和代码。同时&#xff0c;会对相关的Bash命令解释&#xff0c;达到增进理解的目的。 2 Hive组件的部署 部署的前…
阅读更多...
探索SpringMVC-HandlerAdapter之RequestMappingHandlerAdapter-参数解析

探索SpringMVC-HandlerAdapter之RequestMappingHandlerAdapter-参数解析

前言 上回&#xff0c;我们大概讲了下HandlerAdapter。今天带大家来认识一下&#xff0c;我们最常用的RequestMappingHandlerAdapter。不过只能给大家先开个头&#xff0c;讲下参数解析。 RequestMappingHandlerAdapter 在介绍HandlerAdapter时&#xff0c;我们就知道Handle…
阅读更多...
自己动手写编译器:从NFA到DFA

自己动手写编译器:从NFA到DFA

上一节我们完成了使用NFA来识别字符串的功能。NFA有个问题就是其状态节点太多&#xff0c;使用起来效率不够好。本节我们介绍一种叫“子集构造”的算法&#xff0c;将拥有多个节点的NFA转化为DFA。在上一节我们描述的epsilon闭包操作可以看到&#xff0c;实际上所有由epsilon边…
阅读更多...
「ARM32」MMU和页表的映射过程详解

「ARM32」MMU和页表的映射过程详解

在ARM32中&#xff0c;MMU主要完成虚拟地址到物理地址的映射&#xff0c;并且能够控制内存的访问权限&#xff0c;而页表是实现上述功能的主要手段。页表又分为一级页表、二级页表&#xff0c;在ARM64中甚至还有三级页表。为了便于理解&#xff0c;本章主要讲述一级页表完成段映…
阅读更多...
centos7 安装Mysql详细教程

centos7 安装Mysql详细教程

centos7 弃用了Mysql&#xff0c;默认安装了MariaDB&#xff0c;MariaDB是Mysql一个分支&#xff0c;所以要想在centos上安装Mysql&#xff0c;需要先进行卸载MariaDB&#xff0c;避免冲突 本次教程所用环境&#xff1a; 腾讯云服务器&#xff1a;centos7Mysql5.7 1. 卸载Ma…
阅读更多...
dubbo源码实践-protocol层-invoker理解

dubbo源码实践-protocol层-invoker理解

1概述Invoker官方解释&#xff1a;Invoker 是实体域&#xff0c;它是 Dubbo 的核心模型&#xff0c;其它模型都向它靠扰&#xff0c;或转换成它&#xff0c;它代表一个可执行体&#xff0c;可向它发起 invoke 调用&#xff0c;它有可能是一个本地的实现&#xff0c;也可能是一个…
阅读更多...
Python 机器学习最常打交道的 27 款工具包

Python 机器学习最常打交道的 27 款工具包

为了大家能够对人工智能常用的 Python 库有一个初步的了解&#xff0c;以选择能够满足自己需求的库进行学习&#xff0c;对目前较为常见的人工智能库进行简要全面的介绍。 1、Numpy NumPy(Numerical Python)是 Python的一个扩展程序库&#xff0c;支持大量的维度数组与矩阵运算…
阅读更多...
Maix Bit（K210）保姆级入门上手教程

Maix Bit（K210）保姆级入门上手教程

Maix Bit&#xff08;K210&#xff09;快速上手 这是K210快速上手系列文章&#xff0c;主要内容是&#xff0c;设备连接&#xff0c;环境准备&#xff0c;运行第一个程序 阅读文章前提&#xff1a;python基础,K210是使用Micropython脚本语法的&#xff0c;因此需要一些python…
阅读更多...
RocketMQ5.0.0部署与实例

RocketMQ5.0.0部署与实例

一、Idea调试1.相关配置文件在E:\rocketmq创建conf、logs、store三个文件夹。从RocketMQ distribution部署目录中将broker.conf、logback_namesrv.xml、logback_broker.xml文件复制到conf目录。如下图所示。其中logback_namesrv.xml、logback_broker.xml分别是NameServer、Brok…
阅读更多...
纯C语言实现动态爱心（详解，初学者也能看懂）

纯C语言实现动态爱心（详解，初学者也能看懂）

文章目录✍动态爱心实现&#x1f496;一段小故事&#xff1a;爱心函数的由来&#x1f388; 创建动态爱心的准备&#xff08;非小白可以跳过&#xff09;1.爱心字符2.对easyx库里面的基础函数的认识①initgraph函数②settextcolor、settextstyle、setbkmode、outtextxy四种函数③…
阅读更多...
PostgresSQL数据库的使用

PostgresSQL数据库的使用

PostgresSQL数据库的使用 下载安装 数据类型 使用指导 数据库操作 连接控制台 psql -h <实例连接地址> -U <用户名> -p <端口号>参数描述实例连接地址RDS PostgreSQL实例的连接地址&#xff0c;本机可用localhost或者127.0.0.1用户名创建的RDS Postgre…
阅读更多...
ES语法扩展

ES语法扩展

剩余参数 剩余参数本质 // 剩余参数的本质const add(x,y,...args)>{console.log(x,y,args);}add();add(1);add(1,2);add(1,2,3,4,5); 剩余参数的注意事项 箭头函数的参数部分即使只有一个剩余参数&#xff0c;也不能省略圆括号使用剩余参数替代arguments获取实际参数剩余…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023