RK3568驱动指南｜第十六篇 SPI-第188章 mcp2515驱动编写：复位函数

瑞芯微RK3568芯片是一款定位中高端的通用型SOC，采用22nm制程工艺，搭载一颗四核Cortex-A55处理器和Mali G52 2EE 图形处理器。RK3568 支持4K 解码和 1080P 编码，支持SATA/PCIE/USB3.0 外围接口。RK3568内置独立NPU，可用于轻量级人工智能应用。RK3568 支持安卓 11 和 linux 系统，主要面向物联网网关、NVR 存储、工控平板、工业检测、工控盒、卡拉 OK、云终端、车载中控等行业。

​
【公众号】迅为电子

【粉丝群】258811263（加群获取驱动文档+例程）

【视频观看】嵌入式学习之Linux驱动（第十六篇 SPI_全新升级）_基于RK3568

【购买链接】迅为RK3568开发板瑞芯微Linux安卓鸿蒙ARM核心板人工智能AI主板

  1. 第188章 mcp2515驱动编写：复位函数

在上一章中填充了mcp2515字符设备注册相关的内容，有了mcp2515对应的设备节点，而实际上仍旧属于编写通用SPI外设驱动的范畴，如果要编写其他外设的SPI驱动程序，同样要完成上一章编写的驱动内容，而从本章节开始才真正进入到mcp2515特性相关驱动的编写，在本章节将填充mcp2515的复位函数。

188.1 理论分析

MCP2515具有五种模式，分别为配置模式、正常模式、休眠模式、仅监听模式和环回模式，只有在配置模式下，才能对关键寄存器进行初始化和配置，当MCP2515上电或者复位时，器件会自动进入配置模式，而MCP2515提供了一系列的SPI指令，SPI指令表如下图所示：

通过向MCP2515发送上述SPI指令就能实现复位、读、写等操作，复位操作对应的指令格式为11000000，在Linux驱动中可以使用spi_write函数来实现向SPI从设备发送数据，spi_write函数定义在include/linux/spi/spi.h文件中，具体内容如下所示：

static inline int
spi_write(struct spi_device *spi, const void *buf, size_t len)
{
	struct spi_transfer	t = {
			.tx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

该函数首先会对要传输的数据以及传输的数据大小进行封装，然后调用spi_sync_transfer函数进行输入传输，spi_write函数传入的第一个参数为spi_device类型的结构体变量，struct spi_device是Linux内核中用于描述SPI从设备的结构体。它包含了与 SPI 设备相关的各种信息和配置选项，该结构体的具体内容如下所示：

struct spi_device {
    struct device dev; // 通用设备模型的设备结构体
    struct spi_controller *controller; // 指向控制器的指针
    struct spi_controller *master; // 兼容层，指向控制器的指针（与controller相同）
    u32 max_speed_hz; // 设备支持的最大速度（以赫兹为单位）
    u8 chip_select; // 片选编号
    u8 bits_per_word; // 每个字的位数
    u16 mode; // SPI 模式配置（包括时钟相位和极性等）
    int irq; // 中断号
    void *controller_state; // 控制器状态的私有数据
    void *controller_data; // 控制器数据的私有数据
    char modalias[SPI_NAME_SIZE]; // 设备别名
    const char *driver_override; // 驱动程序覆盖
    int cs_gpio; // 片选 GPIO 引脚
    struct spi_statistics statistics; // 统计数据

    /* mode flags */
    #define SPI_CPHA 0x01 // 时钟相位
    #define SPI_CPOL 0x02 // 时钟极性
    #define SPI_MODE_0 (0|0) // 模式0
    #define SPI_MODE_1 (0|SPI_CPHA) // 模式1
    #define SPI_MODE_2 (SPI_CPOL|0) // 模式2
    #define SPI_MODE_3 (SPI_CPOL|SPI_CPHA) // 模式3
    #define SPI_CS_HIGH 0x04 // 片选高电平有效
    #define SPI_LSB_FIRST 0x08 // 最低有效位先传输
    #define SPI_3WIRE 0x10 // 三线模式
    #define SPI_LOOP 0x20 // 环回模式
    #define SPI_NO_CS 0x40 // 无片选信号
    #define SPI_READY 0x80 // 从设备拉低以暂停
    #define SPI_TX_DUAL 0x100 // 双线发送
    #define SPI_TX_QUAD 0x200 // 四线发送
    #define SPI_RX_DUAL 0x400 // 双线接收
    #define SPI_RX_QUAD 0x800 // 四线接收
    #define SPI_CS_WORD 0x1000 // 每个字后切换片选
};

所以在调用spi_write函数之前需要先定义一个struct spi_device类型的用于描述SPI设备的结构体，然后来编写MCP2515的复位函数，编写完成如下所示：

struct spi_device *spi_dev; // SPI设备指针

// MCP2515芯片复位函数
void mcp2515_reset(void){
    int ret;
    char write_buf[] = {0xc0}; // 复位指令0x11000000即0xc0
    ret = spi_write(spi_dev, write_buf, sizeof(write_buf)); // 发送复位命令
    if(ret < 0){
        printk("spi_write is error\n"); // 打印错误信息
    }
}

由于这里只编写了MCP2515的复位函数，无法进行验证，所以本章节并不能进行相应的实验，在下个小节中将会对SPI通信流程进行讲解。

188.2 SPI通信流程

在上个小节中讲解的spi_write函数可以向SPI从设备发送数据，而spi_read函数可以接收从设备发送的数据，spi_read函数具体内容如下所示：

static inline int
spi_read(struct spi_device *spi, void *buf, size_t len)
{
	struct spi_transfer	t = {
			.rx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

跟spi_write函数相同，spi_read函数也会对数据进行封包的操作，将数据buf以及数据大小len封包成spi_transfer类型的结构体，struct spi_transfer是一个描述SPI数据传输的结构体，用于配置一次SPI数据传输的各种参数，该结构体的具体内容如下所示：

struct spi_transfer {
    const void *tx_buf;    // 发送缓冲区
    void *rx_buf;          // 接收缓冲区
    unsigned len;          // 传输数据的长度

    dma_addr_t tx_dma;     // 发送缓冲区的 DMA 地址
    dma_addr_t rx_dma;     // 接收缓冲区的 DMA 地址
    struct sg_table tx_sg; // 发送缓冲区的散列-聚集表
    struct sg_table rx_sg; // 接收缓冲区的散列-聚集表

    unsigned cs_change:1;  // 是否在传输后改变片选状态
    unsigned tx_nbits:3;   // 发送的位数（单线、双线或四线传输）
    unsigned rx_nbits:3;   // 接收的位数（单线、双线或四线传输）

    #define SPI_NBITS_SINGLE 0x01 // 1 位传输
    #define SPI_NBITS_DUAL   0x02 // 2 位传输
    #define SPI_NBITS_QUAD   0x04 // 4 位传输

    u8 bits_per_word;     // 每个字的位数
    u16 delay_usecs;      // 传输之间的延迟（微秒）
    u32 speed_hz;         // 传输速度（赫兹）
    u16 word_delay;       // 每个字之间的延迟

    struct list_head transfer_list; // 传输链表，用于将多个传输串联起来
};

而spi_write函数和spi_read函数只差在struct spi_transfer结构体参数的不同，而封装为struct spi_transfer之后还需要再一次进行封装，spi_write函数和spi_read函数最后都会调用 spi_sync_transfer函数，该函数的具体内容如下所示：

static inline int
spi_sync_transfer(struct spi_device *spi, struct spi_transfer *xfers,
	unsigned int num_xfers)
{
	struct spi_message msg;

	// 使用给定的传输初始化 SPI 消息
	spi_message_init_with_transfers(&msg, xfers, num_xfers);

	// 同步方式发送 SPI 消息
	return spi_sync(spi, &msg);
}

这个函数主要用于封装 SPI 同步传输操作，简化了调用过程。在第8行调用了spi_message_init_with_transfers函数进行SPI传输数据的初始化，最后在第11行调用spi_sync函数采用同步的方式发送SPI数据，spi_sync函数的具体内容如下所示：

int spi_sync(struct spi_device *spi, struct spi_message *message)
{
	int ret;

	// 锁定 SPI 控制器的总线锁互斥体
	mutex_lock(&spi->controller->bus_lock_mutex);
	// 执行同步 SPI 传输
	ret = __spi_sync(spi, message);
	// 解锁 SPI 控制器的总线锁互斥体
	mutex_unlock(&spi->controller->bus_lock_mutex);

	return ret;
}

该函数的主要作用是确保SPI数据传输操作在一个互斥锁的保护下进行，以避免并发传输导致的冲突和数据错误。通过调用内部的 __spi_sync 函数来执行实际的数据传输。__spi_sync函数如下所示：

static int __spi_sync(struct spi_device *spi, struct spi_message *message)
{
	// 声明并初始化一个完成变量
	DECLARE_COMPLETION_ONSTACK(done);
	int status;
	struct spi_controller *ctlr = spi->controller;
	unsigned long flags;

	// 验证 SPI 设备和消息
	status = __spi_validate(spi, message);
	if (status != 0)
		return status;

	// 设置消息完成回调和上下文
	message->complete = spi_complete;
	message->context = &done;
	message->spi = spi;

	// 更新统计信息
	SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync);
	SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);

	/* 如果我们不使用旧的传输方法，
	 * 那么我们将在调用上下文中尝试传输以进行特殊处理。
	 * 如果我们能够删除对驱动程序实现的消息队列的支持，这段代码会更简单。
	 */
	if (ctlr->transfer == spi_queued_transfer) {
		// 锁定总线锁旋转锁并保存中断标志
		spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);

		// 记录 SPI 消息提交的跟踪信息
		trace_spi_message_submit(message);

		// 执行队列传输
		status = __spi_queued_transfer(spi, message, false);

		// 解锁总线锁旋转锁并恢复中断标志
		spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
	} else {
		// 异步锁定传输
		status = spi_async_locked(spi, message);
	}

	if (status == 0) {
		/* 如果可以，则在调用上下文中推送消息 */
		if (ctlr->transfer == spi_queued_transfer) {
			// 更新同步立即传输的统计信息
			SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync_immediate);
			SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync_immediate);
			// 推送消息
			__spi_pump_messages(ctlr, false);
		}

		// 等待完成
		wait_for_completion(&done);
		// 获取消息的状态
		status = message->status;
	}
	// 清除消息的上下文
	message->context = NULL;
	return status;
}

该函数的主要作用是在锁定的上下文中同步执行SPI消息传输。它负责初始化传输消息，验证消息和设备的有效性，处理传输，并在完成后返回传输的状态。该函数的重点在__spi_pump_messages推送消息函数，该函数的具体内容如下所示：

static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
{
	unsigned long flags;
	bool was_busy = false;
	int ret;

	/* 锁定消息队列 */
	spin_lock_irqsave(&ctlr->queue_lock, flags);

	/* 确保没有其他消息正在处理 */
	if (ctlr->cur_msg) {
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 如果另一个上下文正在空闲设备，则推迟处理 */
	if (ctlr->idling) {
		kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 检查队列是否空闲 */
	if (list_empty(&ctlr->queue) || !ctlr->running) {
		if (!ctlr->busy) {
			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
			return;
		}

		/* 只有在线程中执行拆除操作 */
		if (!in_kthread) {
			kthread_queue_work(&ctlr->kworker,
					   &ctlr->pump_messages);
			spin_unlock_irqrestore(&ctlr->queue_lock, flags);
			return;
		}

		ctlr->busy = false;
		ctlr->idling = true;
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);

		kfree(ctlr->dummy_rx);
		ctlr->dummy_rx = NULL;
		kfree(ctlr->dummy_tx);
		ctlr->dummy_tx = NULL;
		if (ctlr->unprepare_transfer_hardware &&
		    ctlr->unprepare_transfer_hardware(ctlr))
			dev_err(&ctlr->dev,
				"failed to unprepare transfer hardware\n");
		if (ctlr->auto_runtime_pm) {
			pm_runtime_mark_last_busy(ctlr->dev.parent);
			pm_runtime_put_autosuspend(ctlr->dev.parent);
		}
		trace_spi_controller_idle(ctlr);

		spin_lock_irqsave(&ctlr->queue_lock, flags);
		ctlr->idling = false;
		spin_unlock_irqrestore(&ctlr->queue_lock, flags);
		return;
	}

	/* 从队列中获取第一个消息 */
	ctlr->cur_msg =
		list_first_entry(&ctlr->queue, struct spi_message, queue);

	list_del_init(&ctlr->cur_msg->queue);
	if (ctlr->busy)
		was_busy = true;
	else
		ctlr->busy = true;
	spin_unlock_irqrestore(&ctlr->queue_lock, flags);

	mutex_lock(&ctlr->io_mutex);

	if (!was_busy && ctlr->auto_runtime_pm) {
		ret = pm_runtime_get_sync(ctlr->dev.parent);
		if (ret < 0) {
			pm_runtime_put_noidle(ctlr->dev.parent);
			dev_err(&ctlr->dev, "Failed to power device: %d\n",
				ret);
			mutex_unlock(&ctlr->io_mutex);
			return;
		}
	}

	if (!was_busy)
		trace_spi_controller_busy(ctlr);

	if (!was_busy && ctlr->prepare_transfer_hardware) {
		ret = ctlr->prepare_transfer_hardware(ctlr);
		if (ret) {
			dev_err(&ctlr->dev,
				"failed to prepare transfer hardware\n");

			if (ctlr->auto_runtime_pm)
				pm_runtime_put(ctlr->dev.parent);
			mutex_unlock(&ctlr->io_mutex);
			return;
		}
	}

	trace_spi_message_start(ctlr->cur_msg);

	if (ctlr->prepare_message) {
		ret = ctlr->prepare_message(ctlr, ctlr->cur_msg);
		if (ret) {
			dev_err(&ctlr->dev, "failed to prepare message: %d\n",
				ret);
			ctlr->cur_msg->status = ret;
			spi_finalize_current_message(ctlr);
			goto out;
		}
		ctlr->cur_msg_prepared = true;
	}

	ret = spi_map_msg(ctlr, ctlr->cur_msg);
	if (ret) {
		ctlr->cur_msg->status = ret;
		spi_finalize_current_message(ctlr);
		goto out;
	}

	ret = ctlr->transfer_one_message(ctlr, ctlr->cur_msg);
	if (ret) {
		dev_err(&ctlr->dev,
			"failed to transfer one message from queue\n");
		goto out;
	}

out:
	mutex_unlock(&ctlr->io_mutex);

	/* 如果成功传输，则唤醒调度器 */
	if (!ret)
		cond_resched();
}

124行代码ctlr->transfer_one_message是一个函数指针，它指向了SPI控制器中负责执行SPI消息传输的函数。通过调用这个函数，将当前的SPI消息 ctlr->cur_msg 传递给该函数进行处理。这个函数通常会负责将消息的数据发送到SPI设备或从设备接收数据，并与硬件设备进行通信。

因此，ctlr->transfer_one_message(ctlr, ctlr->cur_msg)这一行代码的作用是将当前的SPI消息传递给SPI控制器中的传输函数进行处理，以完成消息的传输操作。

至此，SPI通信过程已经分析完毕，而除了spi_write和spi_read函数，还有第三个常用函数spi_write_then_read，该函数的作用为先写后读，在后面的章节中会用到该函数，该函数的具体内容如下所示：

int spi_write_then_read(struct spi_device *spi,
		const void *txbuf, unsigned n_tx,
		void *rxbuf, unsigned n_rx)
{
	// 定义一个静态互斥锁
	static DEFINE_MUTEX(lock);

	int			status;
	struct spi_message	message;
	struct spi_transfer	x[2];
	u8			*local_buf;

	/* 如果可以的话，使用预分配的 DMA 安全缓冲区。我们不能避免
	 * 在这里进行拷贝操作（作为一种纯粹的方便操作），但是我们可以
	 * 在缓冲区未被其他进程使用或传输不太大的情况下，
	 * 避免在热路径上分配堆内存。
	 */
	if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
		local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx),
				    GFP_KERNEL | GFP_DMA);
		if (!local_buf)
			return -ENOMEM; // 如果内存分配失败，返回错误码
	} else {
		local_buf = buf;
	}

	// 初始化 SPI 消息
	spi_message_init(&message);
	memset(x, 0, sizeof(x));
	if (n_tx) {
		x[0].len = n_tx;
		spi_message_add_tail(&x[0], &message);
	}
	if (n_rx) {
		x[1].len = n_rx;
		spi_message_add_tail(&x[1], &message);
	}

	// 将发送数据复制到本地缓冲区
	memcpy(local_buf, txbuf, n_tx);
	x[0].tx_buf = local_buf;
	x[1].rx_buf = local_buf + n_tx;

	/* 执行 I/O 操作 */
	status = spi_sync(spi, &message);
	if (status == 0)
		// 如果传输成功，将接收数据复制到接收缓冲区
		memcpy(rxbuf, x[1].rx_buf, n_rx);

	// 释放锁或释放内存
	if (x[0].tx_buf == buf)
		mutex_unlock(&lock);
	else
		kfree(local_buf);

	return status; // 返回传输状态
}

至此，关于常用的SPI通信函数以及SPI通信流程就讲解完成了，在下个章节中将会继续对MCP2515驱动程序进行完善。

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

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

相关文章

Redux 使用及基本原理

Redux 使用及基本原理

什么是Redux Redux 是用于js应用的状态管理库&#xff0c;通常和React一起用。帮助开发者管理应用中各个组件之间的状态&#xff0c;使得状态的变化变得更加可预测和易于调试。 Redu也可以不和React组合使用。&#xff08;通常一起使用&#xff09; Redux 三大原则 单一数据源…
阅读更多...
在uni-app使用vue3使用vuex

在uni-app使用vue3使用vuex

在uni-app使用vue3使用vuex 1.在项目目录中新建一个store目录&#xff0c;并且新建一个index.js文件 import { createStore } from vuex;export default createStore({//数据&#xff0c;相当于datastate: {count:1,list: [{name: 测试1, value: test1},{name: 测试2, value: …
阅读更多...
从hugging face 下模型

从hugging face 下模型

支持国内下载hugging face 的东西 下模型权重 model_id 是红色圈复制的 代码 记得设置下载的存储位置 import os from pathlib import Path from huggingface_hub import hf_hub_download from huggingface_hub import snapshot_downloadmodel_id"llava-hf/llava-v1…
阅读更多...
Swift 中强大的 Key Paths（键路径）机制趣谈（下）

Swift 中强大的 Key Paths（键路径）机制趣谈（下）

概览 在上一篇博文 Swift 中强大的 Key Paths（键路径）机制趣谈（上）中，我们介绍了 Swift 语言中键路径机制的基础知识，并举了若干例子讨论了它的一些用武之地。 而在本文中我们将再接再厉，继续有趣的键路径大冒险，为 KeyPaths 画上一个圆满的句号。 在本篇博文中，您将…
阅读更多...
C++：二维数组的遍历

C++：二维数组的遍历

方式一&#xff1a; #include <vector> #include <iostream> int main() { // 初始化一个2x3的二维向量&#xff08;矩阵&#xff09; std::vector<std::vector<float>> matrix { {1.0, 2.0, 3.0}, // 第一行 {4.0, 5.0, 6.0} // 第二行 };…
阅读更多...
企业备份NAS存储一体机

企业备份NAS存储一体机

企业文件服务器上的数据、员工电脑里的数据以及NAS存储内数据&#xff0c;需要及时备份&#xff0c;Inforternd存储设备内置了强大的备份服务器功能&#xff0c;无需额外费用&#xff0c;就能轻松将重要数据备份至安全可靠的存储空间中。 无论是GS或GSe 统一存储产品&#xff0…
阅读更多...
开放式耳机怎么选？五大2024年口碑销量爆棚机型力荐！

开放式耳机怎么选？五大2024年口碑销量爆棚机型力荐！

在选购开放式耳机的时候&#xff0c;我们总会因为有太多的选择而陷入两难&#xff0c;又想要一个颜值比较高的&#xff0c;又想要同时兼顾性能还不错的&#xff0c;所以作为测评博主&#xff0c;今天我们就给大家带来自己的一些选购技巧和自己觉得还不错开放式耳机&#xff0c;…
阅读更多...
不同行业如何选择适合自己行业的项目管理工具？

不同行业如何选择适合自己行业的项目管理工具？

在当今的信息化时代&#xff0c;项目管理软件已成为各行各业不可或缺的工具。然而&#xff0c;由于各行业具有不同的特点和需求&#xff0c;因此选择合适的项目管理软件成为了一个重要问题。本文将探讨不同行业在选择项目管理软件时需要考虑的因素&#xff0c;希望能帮助大家更…
阅读更多...
python-图像模糊处理（赛氪OJ）

python-图像模糊处理（赛氪OJ）

[题目描述] 给定 n 行 m 列的图像各像素点的灰度值&#xff0c;要求用如下方法对其进行模糊化处理&#xff1a; 1. 四周最外侧的像素点灰度值不变。 2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均&#xff08;四舍五入&#xff09;输入&#xff…
阅读更多...
安卓微商大师V3.4.0/高级版一键群发僵尸粉检测

安卓微商大师V3.4.0/高级版一键群发僵尸粉检测

一款高效获取客源&#xff0c;备受好评的微商工具&#xff0c;资源丰富&#xff0c;秒速获得客源&#xff0c;大量群客源&#xff0c;都是散客&#xff0c;携手创业&#xff0c;是做微商生意的首选工具。打开即是黑钻高级会员 赶快体验吧 很强大 链接&#xff1a;https://pan.…
阅读更多...
针对 Windows 10 的功能更新，版本 22H2 - 错误 0xc1900204

针对 Windows 10 的功能更新，版本 22H2 - 错误 0xc1900204

最近想帮女朋友生win11发现她电脑安装更新总是卡到安装%10这里失败 原来是安装路径被修改过了&#xff0c;改回c盘 win R → 输入regedit 计算机\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion
阅读更多...
分布式日志采集 Loki 配置及部署详细

分布式日志采集 Loki 配置及部署详细

分布式日志采集 Loki 配置及部署详细 Loki 部署模式Loki 读写分离部署配置Loki 配置大全 Loki 部署模式 &#xff08;1&#xff09;可扩展部署模式 Loki 的简单可扩展部署模式是最简单的部署方式、首选方式。可扩展到每天几TB的日志&#xff0c;但是如果超出这个范围&#xff…
阅读更多...
线下生鲜蔬果店做小程序有什么方法

线下生鲜蔬果店做小程序有什么方法

生鲜蔬果是生活所需&#xff0c;大小商家众多&#xff0c;零售批发各种经营模式&#xff0c;小摊贩或是超市门店都有着目标客户或准属性群体。竞争和获客转化也促进着商家寻找客源和加快线上进程。 尤其是以微信社交为主的私域场景&#xff0c;普客/会员都需要精细化管理营收和…
阅读更多...
WebSocket解决方案(springboot 基于Redis发布订阅)

WebSocket解决方案(springboot 基于Redis发布订阅)

WebSocket 因为一般的请求都是HTTP请求&#xff08;单向通信&#xff09;&#xff0c;HTTP是一个短连接&#xff08;非持久化&#xff09;&#xff0c;且通信只能由客户端发起&#xff0c;HTTP协议做不到服务器主动向客户端推送消息。WebSocket确能很好的解决这个问题&…
阅读更多...
携手共筑爱的桥梁：引导接纳自闭症同学

携手共筑爱的桥梁：引导接纳自闭症同学

在孩子的班级中&#xff0c;当自闭症儿童成为我们共同的一员时&#xff0c;作为老师和家长&#xff0c;我们肩负着特别的责任——引导孩子们以开放的心态接纳、善待并关爱他们。 首先&#xff0c;我们要以身作则&#xff0c;展现接纳与尊重。无论是老师还是家长&#xff0c;都…
阅读更多...
【计算机网络】计算机网络的分类

【计算机网络】计算机网络的分类

计算机网络的分类 导读一、按分布范围分类1.1 广域网&#xff08;WAN&#xff09;。1.2 城域网&#xff08;MAN&#xff09;1.3 局域网&#xff08;LAN&#xff09;1.4 个人区域网&#xff08;PAN&#xff09;1.5 多处理器系统 二、按传输技术分类2.1 广播式网络2.2 点对点网络…
阅读更多...
Ajax异步请求 axios

Ajax异步请求 axios

Ajax异步请求 axios 1 axios介绍 原生ajax请求的代码编写太过繁琐,我们可以使用axios这个库来简化操作&#xff01; 在后续学习的Vue(前端框架)中发送异步请求,使用的就是axios. 需要注意的是axios不是vue的插件,它可以独立使用. axios说明网站&#xff1a;(https://www.kancl…
阅读更多...
【数据结构】04.双向链表

【数据结构】04.双向链表

一、双向链表的结构 注意&#xff1a;这里的“带头”跟前面我们说的“头节点”是两个概念&#xff0c;带头链表里的头节点&#xff0c;实际为“哨兵位”&#xff0c;哨兵位节点不存储任何有效元素&#xff0c;只是站在这里“放哨的”。 “哨兵位”存在的意义&#xff1a;遍历循…
阅读更多...
揭秘,PyArmor库让你的Python代码更安全

揭秘,PyArmor库让你的Python代码更安全

PyArmor 概述: PyArmor 是一个用于加密和保护 Python 源代码的工具,旨在防止代码被逆向工程和未经授权的使用.通过将 Python 源代码编译为加密的字节码,PyArmor 提供了一种有效的方法来保护知识产权和敏感算法. 安装 pip install pyarmor安装完成后,可以通过以下命令验证安装…
阅读更多...
LLM端侧部署系列 | 手机上运行47B大模型?上交推理框架PowerInfer-2助力AI手机端侧部署

LLM端侧部署系列 | 手机上运行47B大模型?上交推理框架PowerInfer-2助力AI手机端侧部署

0. 引言 黄梅时节家家雨&#xff0c;青草池塘处处蛙。 有约不来过夜半&#xff0c;闲敲棋子落灯花。 当下&#xff0c;在移动设备上部署大型模型的趋势是愈演愈烈。Google推出了AI Core&#xff0c;使得Gemini Nano可以在智能手机上部署。此外&#xff0c;近期传闻苹果在iOS …
阅读更多...
最新文章

Copyright @ 2022~2023