YOLOv8目标检测——详细记录使用ONNX Runtime进行推理部署C++/Python实现

YOLOv8模型ONNX跨平台部署:从导出到C++/Python推理实战 在深度学习模型部署领域,ONNX(Open Neural Network Exchange)作为一种开放的模型格式标准,通过将PyTorch、TensorFlow等框架训练的模型转换为统一的中间表示,解决了跨框架和跨硬件平台的部署难题。其核心原理在于定义了一套通用的计算图表示,使得模型可以脱离训练框架,由ONNX Runtime等高性能推理引擎在各种设备上高效执行。这一技术为AI工程化带来了巨大价值,显著提升了研发效率和部署灵活性,广泛应用于服务器、边缘计算和嵌入式设备等场景。本文聚焦于将前沿的YOLOv8 阅读详情
AI摘要

本文介绍了ONNX Runtime原理及使用其进行推理加速,将YOLOv8的.pt模型转换为.onnx模型,并分别用Python和C++实现模型推理。详细说明了环境部署、推理步骤(图像预处理、模型推理、后处理)及代码部署,还提及了C++实现的优势和推理测试。

概述

在之前博客中有介绍YOLOv8从环境安装到训练的完整过程,本节主要介绍ONNX Runtime的原理以及使用其进行推理加速,使用Python、C++两种编程语言来实现。
https://blog.csdn.net/MariLN/article/details/143924548?spm=1001.2014.3001.5501

1. ONNX Runtime

ONNX Runtime是一个由微软推出的跨平台机器学习模型加速器,它仅支持 ONNX 模型格式。它适用于桌面、服务器以及移动设备。

  • 多框架支持:支持多种常见的深度学习框架,如 PyTorch、TensorFlow、Keras、scikit-learn 等,使开发者能轻松将不同框架训练的模型移植到 ONNX Runtime 中进行高效推理,促进了模型在不同框架间的共享与流转。
  • 跨平台兼容性:可在 Linux、Windows、macOS 等多种操作系统上运行,还支持在云、边缘、网页和移动等不同环境中部署,能很好地满足各种应用场景的需求。
  • 硬件优化:针对 GPU、CPU 以及各种 AI 加速器(如 Intel MKL、cuDNN、TensorRT 等)进行了优化,能够充分利用硬件资源提升性能。例如,在 GPU 上可实现并行计算,大大加快模型的推理速度。
  • 高效的内存管理:采用零拷贝(Zero-Copy)技术和内存池管理,减少了数据传输的开销,提升了整体运行速度,在处理大规模数据时优势明显。
  • 动态形状支持:允许输入尺寸在运行时发生变化,模型仍能正确处理,增加了模型应用的灵活性,可更好地适应不同的输入数据情况。

2. 模型转换

2.1 .pt与.onnx模型

2.1.1 pt 模型

.pt 模型是 PyTorch 模型的一种常见存储格式。PyTorch 是一个广泛使用的深度学习框架,在训练神经网络模型时,模型的参数(包括权重和偏置等)会被保存下来,这些参数可以以.pt 文件的形式存储在磁盘中。例如,当你使用 PyTorch 训练一个图像分类模型(如 ResNet)后,通过torch.save()函数就可以将训练好的模型保存为.pt 文件。

本质上它是一个二进制文件,它包含了模型的结构定义和参数。模型的结构定义包括网络的层数、每层的类型(如线性层、卷积层、池化层等)、激活函数的类型等信息。参数则是在训练过程中学习到的具体数值,这些数值决定了模型对输入数据的处理方式。

2.1.2 onnx 模型

ONNX(Open Neural Network Exchange)是一种开放的神经网络交换格式,.onnx 文件就是以这种格式存储的模型文件。它的出现是为了解决不同深度学习框架之间模型转换和互用的问题。许多深度学习框架(如 PyTorch、TensorFlow 等)都可以将自己的模型转换为 ONNX 格式。以 PyTorch 为例,通过torch.onnx.export()函数可以将.pt 模型转换为.onnx 模型。

.onnx 文件同样是一种结构化的文件,它以一种中间表示的形式存储了模型的计算图。这个计算图包含了模型中的各种操作(如加法、乘法、卷积等)以及操作之间的连接关系,同时也包含了模型的输入和输出信息。这种中间表示形式使得不同框架训练的模型能够在一个统一的格式下进行转换和推理。

.onnx 模型主要用于模型的跨框架部署和推理。由于它可以被多种推理引擎(如 ONNX Runtime、TensorRT 等)所支持,所以可以将在一个框架下训练好的模型转换为.onnx 格式,然后在其他环境中进行高效的推理。例如,在工业生产环境中,模型可能是在 PyTorch 中训练的,但在实际的产品线上,需要将其部署到一个对性能和效率要求更高的推理引擎上,此时将模型转换为.onnx 文件并使用 ONNX Runtime 等推理引擎进行部署就非常方便。同时,它也方便了不同团队之间的协作,即使不同团队使用不同的深度学习框架,也可以通过.onnx 文件进行模型的共享和集成。

2.2 .pt转换.onnx

将训练好的 YOLOv8 的.pt模型转换为.onnx模型。可以使用ultralytics库来进行转换。

yolo task=detect mode=export model=./runs/detect/train/weights/best.pt format=onnx

或

from ultralytics import YOLO

# Load a model
model = YOLO('./runs/detect/train/weights/best.pt')  # load a custom trained

# Export the model
success = model.export(format='onnx')

3. 模型推理

3.1 Python实现

3.1.1 环境部署

需要安装onnxruntime、numpy、cv2等库。如果使用 GPU 进行推理,还需安装onnxruntime-gpu。

pip install onnxruntime
pip install onnxruntime-gpu
pip install opencv-python
pip install numpy
pip install gradio

3.1.2 推理步骤

(1)图像预处理
  • 读取图像并将图像的颜色空间从 BGR 格式转换为 RGB 格式。OpenCV 默认使用 BGR 格式,而许多深度学习框架和模型(如 ONNX 模型)则期望输入是 RGB 格式。
  • 调整图像大小,通常将图像 resize 到模型要求的输入尺寸,如 640x640。
  • 对图像进行归一化处理,将像素值归一化到 [0, 1] 区间。
  • 调整图像通道顺序,一般从 HWC(Height, Width, Channel)转换为 CHW 格式,并增加一个批次维度,使其变为 NCHW 格式,N 为批次大小,通常设为 1。
import cv2
import numpy as np

def prepare_input(image, input_width, input_height):
	# 转换为 RGB 格式
	input_img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)# cv2.imread 读取到的图像默认是 BGR 格式的

	# 调整图像尺寸
	input_img = cv2.resize(input_img, (input_width, input_height))# input_width、input_height是模型期望的输入宽度和高度

	# 归一化到 0-1
	input_img = input_img / 255.0

	# 变换通道顺序,并增加 batch 维度,HWC->NCHW
	input_img = input_img.transpose(2, 0, 1)
	input_tensor = input_img[np.newaxis, :, :, :].astype(np.float32)# np.newaxis 用于增加一个新的维度

    return input_tensor

image_path = "test.jpg"
image = cv2.imread(image_path)
input_tensor= prepare_input(image, 640, 640)

(2)模型推理
  • 创建onnxruntime.InferenceSession对象,加载转换后的.onnx模型 。
  • 将预处理后的图像数据作为输入,传递给模型进行推理,并获取输出结果。
def inference(model_path, input_tensor):

    start = time.perf_counter() # 获取一个高精度的时间戳,主要用于代码性能测试和计算时间间隔,精确度通常远高于 time.time()
    
    # 加载 ONNX 模型
    session = onnxruntime.InferenceSession(model_path, providers=onnxruntime.get_available_providers())

	# 获取输入和输出的名字
    input_names = [model_inputs.name for model_inputs in session.get_inputs()]
    output_names = [model_outputs.name for model_outputs in session.get_outputs()]
    
    # 运行模型推理
    outputs = session.run(output_names, {
   
   input_names[0]: input_tensor})
   
    print(f"Inference time: {
     
     (time.perf_counter() - start)*1000:.2f} ms")
    return outputs
    
(3)后处理
  • 对模型的输出结果去除批量维度。
  • 获取每个检测框的置信度最高的类别,并根据置信度阈值进行筛选,过滤掉低置信度的目标检测框 。
  • 坐标转换,将预测框还原到原始图像尺寸,并将边界框的表示从中心点坐标 (x_center, y_center) 和宽高 (w, h) 格式转换为左上角和右下角坐标 (x1, y1, x2, y2) 格式。
  • 进行非极大值抑制(NMS),去除重叠度过高的检测框,得到最终的目标检测结果。
def xywh2xyxy(x):
    # 将边界框从 (x_center, y_center, w, h) 格式转换为 (x1, y1, x2, y2)
    y = np.copy(x)

    # 计算左上角坐标 x1 和 y1
    y[..., 0] = x[..., 0] - x[..., 2] / 2  # x1 = x_center - w / 2
    y[..., 1] = x[..., 1] - x[..., 3] / 2  # y1 = y_center - h / 2

    # 计算右下角坐标 x2 和 y2
    y[..., 2] = x[..., 0] + x[..., 2] / 2  # x2 = x_center + w / 2
    y[..., 3] = x[..., 1] + x[..., 3] / 2  # y2 = y_center + h / 2

    return y

def multiclass_nms(boxes, scores, class_ids, iou_threshold):

    # 获取所有唯一的类别索引
    unique_class_ids = np.unique(class_ids)

    keep_boxes = []  # 存储最终保留的边界框索引
    
    for class_id in unique_class_ids:
        # 筛选出属于当前类别的边界框索引
        class_indices = np.where(class_ids == class_id)[0] # np.where返回元组
        
        # 提取属于当前类别的边界框和分数
        class_boxes = boxes[class_indices, :]   # 当前类别的边界框
        class_scores = scores[class_indices]   # 当前类别的分数

        # 执行 NMS 并获取保留下来的索引
        class_keep_boxes = nms(class_boxes, class_scores, iou_threshold)

        # 将保留的索引(对应原始的索引)添加到结果中
        keep_boxes.extend(class_indices[class_keep_boxes])

    return keep_boxes

def nms(boxes, scores, iou_threshold):
    # 根据 scores 对检测框从高到低进行排序,得到排序后的索引
    sorted_indices = np.argsort(scores)[::-1] # [::-1] 反转排序顺序

    keep_boxes = []
    while sorted_indices.size > 0:
        # 保留最高分数的边界框
        box_id = sorted_indices[0]
        keep_boxes.append(box_id)

        # 计算当前最高分数的边界框与剩余边界框的 IoU
        ious = compute_iou(boxes[box_id, :], boxes[sorted_indices[1:], :])

        # 找出 IoU 小于阈值的边界框索引,保留这些框,过滤重叠框
        keep_indices = np.where(ious < iou_threshold)[0]

        # 注意:由于 keep_indices 是相对于 sorted_indices[1:] 的索引,
        # 需要将其整体偏移 +1 来匹配到原始 sorted_indices
        sorted_indices = sorted_indices[keep_indices + 1]

    return keep_boxes

def compute_iou(box, boxes):

    # 计算交集区域的坐标,xmin 和 ymin: 交集左上角的坐标,xmax 和 ymax: 交集右下角的坐标
    xmin = np.maximum(box[0], boxes[:, 0]) 
    ymin = np.maximum(box[1], boxes[:, 1]) 
    xmax = np.minimum(box[2], boxes[:, 2]) 
    ymax = np.minimum(box[3], boxes[:, 3])  

    # 计算交集区域面积,如果两个框没有重叠,交集宽度和高度会为负,使用 np.maximum 保证面积非负
    intersection_area = np.maximum(0, xmax - xmin) * np.maximum(0, ymax - ymin)

    # 计算每个边界框的面积
    box_area = (box[2] - box[0]) * (box[3] - box[1])  
    boxes_area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])  

    # 计算并集区域面积
    union_area = box_area + boxes_area - intersection_area

    # 计算 IoU(交并比)
    iou = intersection_area / union_area  # 交集区域面积 / 并集区域面积

    return iou


def process_output(outputs, conf_threshold, iou_threshold, input_width, input_height, img_width, img_height):

    predictions = np.squeeze(outputs[0]).T # 去除数组中形状为1的维度,批量维度,(1, N, M)->(M, N)

    # 获取每个检测框的置信度最高的类别
    scores = np.max(predictions[:, 4:], axis=1) # 在行方向上取最大值
    # 根据置信度阈值过滤掉低置信度的检测框
    predictions = predictions[scores > conf_threshold, :]
    scores = scores[scores > conf_threshold]

    if len(scores) == 0:
        return [], [], []

    # 获取检测框的类别置信度最高的索引
    class_ids = np.argmax(predictions[:, 4:], axis=1) # 返回数组中最大值的索引

    # 提取边界框
    boxes = predictions[:, :4]
    
    # 将边界框坐标从归一化坐标还原到原图尺寸
    input_shape = np.array([input_width, input_height, input_width, input_height])
    boxes = np.divide(boxes, input_shape, dtype=np.float32) # 边界框坐标是相对于输入图像尺寸的,归一化到 [0, 1] 之间
    boxes *= np.array([img_width, img_height, img_width, img_height]) # 将归一化的坐标还原到原图尺寸

    # 转换为 xyxy 格式
    boxes = xywh2xyxy(boxes)

    # 执行非极大值抑制(NMS)
    indices = multiclass_nms(boxes, scores, class_ids, iou_threshold)

    return boxes[indices], scores[indices], class_ids[indices]

3.1.3 代码部署

utils.py

import numpy as np
import cv2

class_names = ['person','head','helmet']

# Create a list of colors for each class where each color is a tuple of 3 integer values
rng = np.random.default_rng(3)
colors = rng.uniform(0, 255, size=(len(class_names), 3))

def nms(boxes, scores, iou_threshold):
    # Sort by score
    sorted_indices = np.argsort(scores)[::-1]

    keep_boxes = []
    while sorted_indices.size > 0:
        # Pick the last box
        box_id = sorted_indices[0]
        keep_boxes.append(box_id)

        # Compute IoU of the picked box with the rest
        ious = compute_iou(boxes[box_id, :], boxes[sorted_indices[1:], :])

        # Remove boxes with IoU over the threshold
        keep_indices = np.where(ious < iou_threshold)[0]

        # print(keep_indices.shape, sorted_indices.shape)
        sorted_indices = sorted_indices[keep_indices + 1]

    return keep_boxes

def multiclass_nms(boxes, scores, class_ids, iou_threshold):

    unique_class_ids = np.unique(class_ids)

    keep_boxes = []
    for class_id in unique_class_ids:
        class_indices = np.where(class_ids == class_id)[0]
        class_boxes = boxes[class_indices,:]
        class_scores = scores[class_indices]

        class_keep_boxes = nms(class_boxes, class_scores, iou_threshold)
        keep_boxes.extend(class_indices[class_keep_boxes])

    return keep_boxes

def compute_iou(box, boxes):
    # Compute xmin, ymin, xmax, ymax for both boxes
    xmin = np.maximum(box[0], boxes[:, 0])
    ymin = np.maximum(box[1], boxes[:, 1])
    xmax = np.minimum(box[2], boxes[:, 2])
    ymax = np.minimum(box[3], boxes[:, 3])

    # Compute intersection area
    intersection_area = np.maximum(0, xmax - xmin) * np.maximum(0, ymax - ymin)

    # Compute union area
    box_area = (box[2] - box[0]) * (box[3] - box[1])
    boxes_area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
    union_area = box_area + boxes_area - intersection_area

    # Compute IoU
    iou = intersection_area / union_area

    return iou

def xywh2xyxy(x):
    # Convert bounding box (x, y, w, h) to bounding box (x1, y1, x2, y2)
    y = np.copy(x)
    y[..., 0] = x[..., 0] - x[..., 2] / 2
    y[..., 1] = x[..., 1] - x[..., 3<
onnx标准 & onnxRuntime加速推理引擎 onnx标准 & onnxRuntime加速推理引擎 文章目录onnx标准 & onnxRuntime加速推理引擎一、onnx简介二、pytorch转onnx三、tf1.0 / tf2.0 ckpt转onnx四、python onnx的使用1、环境安装2、获得onnx模型权重参数(可视化)3、onnx模型推理 参考博客: ONNX运行时:跨平台、高性能ML推断和训练加速器 python关于onnx模型的一些基本操作 ONNX 與 Azure Machine Learning:建立並加速 M 阅读详情

相关推荐

onnxruntime-gpu使用记录

使用onnxruntime-gpu进行模型推理

chen_znn的博客 3407

C#集成YOLOv8目标检测:30分钟实现WinForm/WPF工业级视觉应用

如果你是一名C#开发者,想在自己的WinForm或WPF应用中集成目标检测能力,但又觉得从零训练模型、配置Python环境、处理复杂的C++依赖过于麻烦,那么这篇文章就是为你准备的。我们将聚焦于一个核心目标: 如何以最低门槛,在C#项目中快速集成并运行YOLOv8模型,实现工业级的实时目标检测。 这个方案的核心价值在于,它绕开了复杂的深度学习框架部署,直接利用成熟的ONNX Runtime推理引擎,让C#开发者能够像调用一个普通类库一样使用YOLOv8。你不需要成为AI专家,只需要关注你的业务逻辑和界面交互

weixin_34205826的博客 3292

YOLOv8 CPU推理性能对比:PyTorch、ONNX Runtime与OpenVINO调优实战

深度学习模型部署中,推理引擎的选型与配置直接决定CPU环境下的运行效率。目标检测模型YOLOv8在无GPU场景中,常依赖PyTorch、ONNX Runtime、OpenVINO等框架完成推理,三者在计算图优化、算子融合、线程调度等方面存在显著差异。文章从推理引擎的基本原理切入,分析静态图优化、输入shape固定、线程绑定等关键技术对CPU性能的影响,并结合英特尔大小核架构的特殊性,对比不同引擎的实测表现。在边缘计算、低成本服务器、工控机等场景中,这些优化方法能有效提升推理速度,为在CPU上部署YOLOv8

weixin_34216196的博客 352

CPU部署YOLOv8实测:ONNX Runtime快1.8倍,OpenVINO调优反超

目标检测模型的部署往往面临推理延迟与硬件成本的权衡,尤其在纯CPU环境下,如何借助推理引擎优化性能成为关键。PyTorch模型虽训练灵活,但动态图机制与Python解释开销导致推理效率偏低。将模型转换为ONNX格式后,ONNX Runtime通过静态图优化、算子融合与内存复用,能在不改变硬件的前提下显著提升速度。OpenVINO作为Intel针对自家CPU深度优化的推理框架,虽默认配置可能受线程调度和动态Shape影响而“翻车”,但通过固定输入Shape、设置低延迟模式并限制CPU线程数,仍可进一步压榨性能

weixin_33937778的博客 328

AI模型部署 | onnxruntime部署YOLOv8分割模型详细教程

本文首发于公众号【DeepDriving】,欢迎关注。

DeepDriving 6203

C# + ONNX Runtime:YOLOv12工业部署的最佳实践

本文介绍了工业场景下将YOLOv12模型通过ONNX Runtime部署到C#环境的最佳实践。主要内容包括: 部署架构设计:采用三层解耦方案(业务层/推理层/硬件层),基于ONNX Runtime实现跨硬件统一推理接口,相比HTTP服务或商业SDK方案具有更高性能和更低成本。 关键技术实现: 环境配置:选择.NET 8 LTS,匹配CUDA/cuDNN版本 ONNX模型导出:建议固定输入尺寸,独立后处理逻辑 核心流程:图像预处理(Letterbox缩放/BGR转RGB)、模型推理(单例InferenceSe

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 413

产线实测:C#上位机+ONNX Runtime部署YOLOv8,从300ms到85ms的优化全记录

工业项目,稳定比先进重要。YOLOv8不是最新的,但够用;C#不是最火的,但好维护;ONNX Runtime不是最快的,但稳定。客户要的不是技术展示,是能连续跑120天不出问题的系统。代码已经整理好,放在GitHub上,有需要的可以拿去用。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 507

YOLOv8 C++部署实战:基于ONNX Runtime的高性能推理模块开发

目标检测是计算机视觉领域的核心任务之一,其原理是通过深度学习模型在图像中定位并识别物体。YOLO系列模型因其在精度与速度间的优异平衡,成为工业界广泛采用的技术。ONNX Runtime作为一个跨平台的高性能推理引擎,为模型部署提供了统一接口,能有效解决框架依赖和性能优化问题。在嵌入式视觉和边缘计算场景中,将训练好的模型高效集成到C++项目中具有重要价值。本文聚焦于YOLOv8模型的C++部署,详细阐述了如何利用ONNX Runtime构建一个包含预处理、推理、后处理全链路的工业级推理模块,并深入探讨了GPU

weixin_34314962的博客 367

C++与ONNX Runtime部署YOLOv8模型:CPU环境下的高效推理实践

模型部署是将训练好的深度学习模型应用于实际生产环境的关键环节,其核心在于实现跨平台、高性能的推理。ONNX(开放神经网络交换)格式作为业界标准,解决了不同训练框架与推理引擎间的模型兼容性问题。ONNX Runtime作为其官方推理引擎,通过高度优化的算子实现和灵活的执行提供者(如CPU EP),在CPU上也能获得显著的推理加速,技术价值在于平衡了性能、通用性与易用性。在计算机视觉领域,目标检测模型如YOLOv8的部署尤为常见,涉及图像预处理、模型推理与后处理(如非极大值抑制)等完整链路。本文聚焦于使用C++

weixin_30520015的博客 292

C++与ONNX Runtime部署YOLOv8:从模型转换到工程实践全解析

模型部署是将训练好的深度学习模型应用于实际生产环境的关键环节,其核心在于实现高效、稳定的跨平台推理。ONNX(Open Neural Network Exchange)作为一种开放的模型格式,解决了不同框架间模型互操作性的难题,而ONNX Runtime则提供了统一的高性能推理引擎。通过将PyTorch等框架训练的模型转换为ONNX格式,开发者可以脱离复杂的Python依赖,在C++等环境中进行部署,这对于追求极致性能、低资源占用或需要集成到现有C++项目中的场景(如边缘计算、嵌入式设备)具有重要价值。本文

weixin_30800807的博客 382

C# WinForms集成YoloV8+ONNX Runtime实现工业电池视觉检测全流程

目标检测是计算机视觉的核心任务之一,旨在识别图像中特定物体的位置与类别。其原理通常基于深度学习模型,通过卷积神经网络提取特征并预测边界框。这项技术的价值在于能够自动化完成以往依赖人眼的识别工作,大幅提升效率与一致性。在工业自动化、安防监控、自动驾驶等场景中,目标检测是实现智能感知的关键。本文聚焦于工业视觉检测这一具体应用,详细阐述了如何将前沿的YoloV8检测模型通过ONNX Runtime推理引擎,无缝集成到成熟的C# WinForms上位机软件中,解决电池正负极方向实时检测的真实需求,为.NET环境下的

weixin_34204722的博客 430

从零开始构建量化价值投资多因子模型

量化价值投资多因子模型的构建目的在于通过系统性的方法,综合考虑多个影响股票价值的因素,以更准确地评估股票的投资价值,为投资者提供科学的投资决策依据。本模型的构建范围涵盖了从因子的选取、数据的处理、模型的建立到模型的评估和优化等一系列过程。通过对历史数据的分析和回测,验证模型的有效性和稳定性,进而应用于实际的投资组合管理中。本文将按照以下结构进行组织:首先介绍量化价值投资和多因子模型的相关背景知识,包括核心概念和联系;接着详细阐述核心算法原理和具体操作步骤,并给出Python代码示例;

AI天才研究院 1250

Linux运维踩坑实录:手把手教你修复LVM中PV显示[unknown]的诡异问题

本文详细解析了Linux运维中LVM物理卷(PV)显示[unknown]的故障现象及修复方法。通过分析问题根源、提供标准修复流程和特殊场景处理方案,帮助运维人员快速解决VG容量异常、PV状态丢失等问题,并分享预防措施与最佳实践,确保LVM存储系统的稳定运行。

weixin_26869081的博客 352

LMI线性矩阵不等式之非线性变量处理

​ 如果一个LMI线性矩阵不等式中的某项存在两个矩阵变量相乘,那么称该类情形为非线性矩阵不等式,而要直接求解时很困难的,而且LMI工具箱也无法求解非线性矩阵,所以需要通过变量替换法进行处理。 ​...

Mr.邹的博客 4552

代号OneNET02 STM32+ESP8266 WIFI系列-第2节-STM32单片机通过ESP8266连接WIFI访问OneNET OTA服务器实现SOTA远程程序升级

第2节-STM32单片机通过ESP8266连接WIFI访问OneNET OTA服务器实现SOTA远程程序升级,这一节主要是实现通过OneNET OTA服务器将需要更新的程序远程下载到STM32单片机,这一节主要是引导程序和应用程序的讲解。

weixin_44862509的博客 1906

Allegro层叠中的Etch Factor-铜皮的腐蚀因子如何计算

在用Allegro进行PCB设计的时候,Cross-section中需要填入对应的信息,一般填入每层的厚度即可,如下图。当PCB需要进行仿真分析的时候,Etch-Factor这个值是必须要填写的,如下图。实际铜皮进行蚀刻的时候,Etch-Factor的值并不是标准的90度,如下图。线路层实际形状是个梯形,Etch-Factor代表的就是梯形的角度,如下图。首先输入数值,比如1,再点击Inv,最后点击tan-1,可以得到角度的值。如果tanσ=2,σ=63.4,如下图计算结果。即tanσ=1,得到σ=45。

weixin_54787054的博客 886

2.Vivado软件基础操作

在本章节,我们以一个简单的计数器实例,介绍FPGA开发软件Vivado的基础操作流程,计数器实例程序的设计,在本课程中先不同掌握,后续课程将针对verilog编程进行讲解。 打开Vivado软件,会看到如下的界面: 点击如下图所示的: 点击Next> 将这个地方,设置路径,注意路径必须是英文路径。且文件夹名称第一个字符不能为数字。所有路径的名称的字符数量不能超过144个符号。 点击Next> 点击Next> 点...

FPGA/MATLAB学习教程/源码/项目合作开发 4484

电磁场仿真软件:Sonnet_(12).Sonnet与其他软件的集成

Sonnet作为电磁场仿真领域的强大工具,不仅能够独立完成复杂的仿真任务,还可以通过与其他软件的集成,实现更高效的工作流程和更广泛的功能扩展。通过与CAD、EDA、数据处理软件、MATLAB、Python以及云计算平台的集成,Sonnet用户可以更好地利用现有设计资源,进行参数优化和结果分析,从而提升设计和仿真效率。希望本节的内容能够帮助你更好地理解和应用Sonnet的集成功能。

kkchenjj的博客 1434

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

上一篇: 深度学习——激活函数的原理与应用
下一篇: 深度学习——模型过拟合和欠拟合的原因及解决方法
发呆小天才O.o
博客等级 码龄2年 3881粉丝 28原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值