【Pytorch】Visualization of Feature Maps（3）

在这里插入图片描述

学习参考来自：

  • Image Style Transform–关于图像风格迁移的介绍
  • github：https://github.com/wmn7/ML_Practice/tree/master/2019_06_03

文章目录

  • 风格迁移

风格迁移

风格迁移出处：

《A Neural Algorithm of Artistic Style》（arXiv-2015）

在这里插入图片描述

在这里插入图片描述

风格迁移的实现

在这里插入图片描述

让 Random Image 在内容上可以接近 Content Image，在风格上可以接近 Style Image，当然， Random Image 可以初始化为 Content Image

导入基本库，数据读取

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

from PIL import Image
import matplotlib.pyplot as plt

import torchvision.transforms as transforms
import torchvision.models as models

import numpy as np
import copy
import os

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")


def image_loader(image_name, imsize):
    loader = transforms.Compose([
        transforms.Resize(imsize),  # scale images
        transforms.ToTensor()
    ])
    image = Image.open(image_name).convert("RGB")
    image = loader(image).unsqueeze(0)
    return image.to(device, torch.float)


def image_util(img_size=512, style_img="./1.jpg", content_img="./2.jpg"):
    "the size of style_img and contend_img should be same"
    imsize = img_size if torch.cuda.is_available() else 128  # use small size if no gpu
    style_img = image_loader(style_img, imsize)
    content_img = image_loader(content_img, imsize)

    print("Style Image Size:{}".format(style_img.size()))
    print("Content Image Size:{}".format(content_img.size()))

    assert style_img.size() == content_img.size(), "we need to import style and content images of the same size"
    return style_img, content_img

定义内容损失

在这里插入图片描述

"content loss"
class ContentLoss(nn.Module):
    def __init__(self, target):
        super(ContentLoss, self).__init__()
        self.target = target.detach()
        
    def forward(self, input):
        self.loss = F.mse_loss(input, self.target)
        return input

定义风格损失

def gram_matrix(input):
    a, b, c, d = input.size()  # N, C,
    features = input.view(a * b, c * d)
    G = torch.mm(features, features.t())
    return G.div(a * b * c * d)

在这里插入图片描述

Gram Matrix 最后输出大小只和 filter 的个数有关（channels），上面的例子输出为 3x3

Gram Matrix 可以表示出特征出现的关系（特征 f1、f2、f3 之间的关系）。

我们可以通过计算 Gram Matrix 的差，来计算两张图片风格上的差距

在这里插入图片描述

class StyleLoss(nn.Module):
    def __init__(self, target_feature):
        # we "detach" the target content from the tree used to dynamically
        # compute the gradient: this is stated value, not a variable .
        # Otherwise the forward method of the criterion will throw an error
        super(StyleLoss, self).__init__()
        self.target = gram_matrix(target_feature).detach()

    def forward(self, input):
        G = gram_matrix(input)
        self.loss = F.mse_loss(G, self.target)
        return input

写好前处理减均值，除方差

"based on VGG-16"
"put the normalization to the first layer"
class  Normalization(nn.Module):
    def __init__(self, mean, std):
        super(Normalization, self).__init__()
        # view the mean and std to make them [C,1,1] so that they can directly work with image Tensor of shape [B,C,H,W]
        self.mean = mean.view(-1, 1, 1)  # [3] -> [3, 1, 1]
        self.std = std.view(-1, 1, 1)

    def forward(self, img):
        return (img - self.mean) / self.std

定义网络，引入 loss

"modify to a style network"
def get_style_model_and_losses(cnn, normalization_mean, normalization_std,
                               style_img, content_img,
                               content_layers,
                               style_layers):
    cnn = copy.deepcopy(cnn)
    # normalization module
    normalization = Normalization(normalization_mean, normalization_std).to(device)

    # just in order to have an iterable acess to or list of content / style
    # losses
    content_losses = []
    style_losses = []

    # assuming that cnn is a nn.Sequantial, so we make a new nn.Sequential to put
    # in modules that are supposed to be activated sequantially
    model = nn.Sequential(normalization)

    i = 0  # increment every time we see a conv
    for layer in cnn.children():
        if isinstance(layer, nn.Conv2d):
            i += 1
            name = "conv_{}".format(i)
        elif isinstance(layer, nn.ReLU):
            name = "relu_{}".format(i)
            layer = nn.ReLU(inplace=False)
        elif isinstance(layer, nn.MaxPool2d):
            name = "pool_{}".format(i)
        elif isinstance(layer, nn.BatchNorm2d):
            name = "bn_{}".format(i)
        else:
            raise RuntimeError("Unrecognized layer: {}".format(layer.__class__.__name__))
        model.add_module(name, layer)

        if name in content_layers:
            # add content loss
            target = model(content_img).detach()
            content_loss = ContentLoss(target)
            model.add_module("content_loss_{}".format(i), content_loss)
            content_losses.append(content_loss)

        if name in style_layers:
            # add style loss
            target_feature = model(style_img).detach()
            style_loss = StyleLoss(target_feature)
            model.add_module("style_loss_{}".format(i), style_loss)
            style_losses.append(style_loss)

    # now we trim off the layers afater the last content and style losses
    for i in range(len(model)-1, -1, -1):
        if isinstance(model[i], ContentLoss) or isinstance(model[i], StyleLoss):
            break
    model = model[:(i+1)]
    return model, style_losses, content_losses

def get_input_optimizer(input_img):
    optimizer = optim.LBFGS([input_img.requires_grad_()])
    return optimizer


def run_style_transfer(cnn, normalization_mean, normalization_std, content_img, style_img, input_img, content_layers,
                       style_layers, num_steps=50, style_weight=1000000, content_weight=1):
    print('Building the style transfer model..')
    model, style_losses, content_losses = get_style_model_and_losses(cnn, normalization_mean, normalization_std,
                                                                     style_img, content_img, content_layers,
                                                                     style_layers)
    optimizer = get_input_optimizer(input_img) # 网络不变，反向传播优化的是输入图片

    print('Optimizing..')
    run = [0]
    while run[0] <= num_steps:

        def closure():
            # correct the values of updated input image
            input_img.data.clamp_(0, 1)

            optimizer.zero_grad()
            model(input_img)  # 前向传播
            style_score = 0
            content_score = 0

            for sl in style_losses:
                style_score += sl.loss
            for cl in content_losses:
                content_score += cl.loss

            style_score *= style_weight
            content_score *= content_weight
            # loss为style loss 和 content loss的和
            loss = style_score + content_score
            loss.backward()  # 反向传播
            # 打印loss的变化情况
            run[0] += 1
            if run[0] % 50 == 0:
                print("run {}:".format(run))
                print('Style Loss : {:4f} Content Loss: {:4f}'.format(
                    style_score.item(), content_score.item()))
                print()

            return style_score + content_score

        # 进行参数优化
        optimizer.step(closure)

    # a last correction...
    # 数值范围的纠正, 使其范围在0-1之间
    input_img.data.clamp_(0, 1)

    return input_img

搭建完成，开始训练，仅优化更新 input image（get_input_optimizer），网络不更新

# 加载content image和style image
style_img,content_img = image_util(img_size=270, style_img="./style9.jpg", content_img="./content.jpg")  # [1, 3, 270, 270]
# input image使用content image
input_img = content_img.clone()
# 加载预训练好的模型
cnn = models.vgg19(pretrained=True).features.to(device).eval()
# 模型标准化的值
cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(device)
cnn_normalization_std = torch.tensor([0.229, 0.224, 0.225]).to(device)
# 定义要计算loss的层
content_layers_default = ['conv_4']
style_layers_default = ['conv_1', 'conv_2', 'conv_3', 'conv_4', 'conv_5']
# 模型进行计算
output = run_style_transfer(cnn, cnn_normalization_mean, cnn_normalization_std,
                            content_img, style_img, input_img,
                            content_layers=content_layers_default,
                            style_layers=style_layers_default,
                            num_steps=300, style_weight=100000, content_weight=1)


image = output.cpu().clone()
image = image.squeeze(0)  # ([1, 3, 270, 270] -> [3, 270, 270])
unloader = transforms.ToPILImage()
image = unloader(image)
import cv2
image = cv2.cvtColor(np.asarray(image), cv2.COLOR_RGB2BGR)
cv2.imwrite("t9.jpg", image)
torch.cuda.empty_cache()

"""VGG-19
Sequential(
  (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): ReLU(inplace=True)
  (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (3): ReLU(inplace=True)
  (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (6): ReLU(inplace=True)
  (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (8): ReLU(inplace=True)
  (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (11): ReLU(inplace=True)
  (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (13): ReLU(inplace=True)
  (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (15): ReLU(inplace=True)
  (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (17): ReLU(inplace=True)
  (18): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (19): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (20): ReLU(inplace=True)
  (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (22): ReLU(inplace=True)
  (23): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (24): ReLU(inplace=True)
  (25): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (26): ReLU(inplace=True)
  (27): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (29): ReLU(inplace=True)
  (30): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (31): ReLU(inplace=True)
  (32): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (33): ReLU(inplace=True)
  (34): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (35): ReLU(inplace=True)
  (36): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
"""


"""modify name, add loss layer
Sequential(
  (0): Normalization()
  (conv_1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_1): StyleLoss()
  (relu_1): ReLU()
  (conv_2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_2): StyleLoss()
  (relu_2): ReLU()
  (pool_2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_3): StyleLoss()
  (relu_3): ReLU()
  (conv_4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (content_loss_4): ContentLoss()
  (style_loss_4): StyleLoss()
  (relu_4): ReLU()
  (pool_4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_5): StyleLoss()
  (relu_5): ReLU()
  (conv_6): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_6): ReLU()
  (conv_7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_7): ReLU()
  (conv_8): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_8): ReLU()
  (pool_8): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_9): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_9): ReLU()
  (conv_10): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_10): ReLU()
  (conv_11): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_11): ReLU()
  (conv_12): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_12): ReLU()
  (pool_12): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_13): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_13): ReLU()
  (conv_14): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_14): ReLU()
  (conv_15): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_15): ReLU()
  (conv_16): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (relu_16): ReLU()
  (pool_16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
"""


"""after trim
Sequential(
  (0): Normalization()
  (conv_1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_1): StyleLoss()
  (relu_1): ReLU()
  (conv_2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_2): StyleLoss()
  (relu_2): ReLU()
  (pool_2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_3): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_3): StyleLoss()
  (relu_3): ReLU()
  (conv_4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (content_loss_4): ContentLoss()
  (style_loss_4): StyleLoss()
  (relu_4): ReLU()
  (pool_4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv_5): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (style_loss_5): StyleLoss()
)
"""

原图，花宝叽

在这里插入图片描述
不同风格

在这里插入图片描述
产生的结果

在这里插入图片描述

更直观的展示

在这里插入图片描述

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

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

相关文章

JS 判断元素是否为空

JS 判断元素是否为空

判断元素是否为空&#xff1a; /*** 判断是否为空*/ export function validatenull(val) {if (typeof val boolean) {return false}if (typeof val number) {return false}if (val instanceof Array) {if (val.length0) return true} else if (val instanceof Object) {if (…
阅读更多...
PC8223（CC/CV控制）高耐压输入5V/3.4A同步降压电路内建补偿带恒流恒压输出

PC8223（CC/CV控制）高耐压输入5V/3.4A同步降压电路内建补偿带恒流恒压输出

概述 PC8233&#xff08;替代CX8853&#xff09;是一款同步降压调节器,输出电流高达3.4A,操作范围从8V到32V的宽电源电压。内部补偿要求最低数量现成的标准外部组件。PC8233在CC&#xff08;恒定输出电流&#xff09;模式或CV&#xff08;恒定输出电压&#xff09;模式&#x…
阅读更多...
uniapp项目开发的功能点

uniapp项目开发的功能点

一.手机 判断什么手机 const platform uni.getSystemInfoSync().platform;//platform ios什么机型 const model uni.getSystemInfoSync().model //model.toindex(iPhone)二.授权登录 授权登录有2种方式 &#xff08;一&#xff09;静默授权 就直接通过uni.login 获取c…
阅读更多...
大模型AI Agent 前沿调研

大模型AI Agent 前沿调研

前言 大模型技术百花齐放&#xff0c;越来越多&#xff0c;同时大模型的落地也在紧锣密鼓的进行着&#xff0c;其中Agent智能体这个概念可谓是火的一滩糊涂。 今天就分享一些Agent相关的前沿研究&#xff08;仅限基于大模型的AI Agent研究&#xff09;&#xff0c;包括一些论…
阅读更多...
解决kubernetes中微服务pod之间调用失败报错connection refused的问题

解决kubernetes中微服务pod之间调用失败报错connection refused的问题

现象&#xff1a; 从这里可以看到是当前服务在调用product service服务是出现了连接拒绝connection refused 走读一下原始代码&#xff1a; 可以看到请求是由FeignClient代理发出的 &#xff0c;但问题在于为什么Feign请求的时候会产生connection refused错误&#xff1f; 上…
阅读更多...
2014年9月26日 Go生态洞察：使用Docker部署Go服务器

2014年9月26日 Go生态洞察：使用Docker部署Go服务器

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
最近整理一份steam搬砖的项目操作细节和详细要求

最近整理一份steam搬砖的项目操作细节和详细要求

csgo饰品搬砖Steam饰品搬砖全套操作流程之如何卖货 一、国外Steam游戏装备汇率差项目 这个项目的基本原理是 购买国外Steam游戏平台上的装备&#xff0c;再在国内网易Buff平台上或国际站csgo饰品平台进行售卖。从充值汇率和两个平台的装备价格差中获得利润。 二、需要准备的硬…
阅读更多...
EMG肌肉电信号处理合集（二）

EMG肌肉电信号处理合集（二）

本文主要展示常见的肌电信号特征的提取说明。使用python 环境下的Pysiology计算库。 目录 1 肌电信号第一次burst的振幅&#xff0c; getAFP 函数 2 肌电信号波长的标准差计算&#xff0c;getDASDV函数 3 肌电信号功率谱频率比例&#xff0c;getFR函数 4 肌电信号直方图…
阅读更多...
738. Monotone Increasing Digits 968. Binary Tree Cameras

738. Monotone Increasing Digits 968. Binary Tree Cameras

738. Monotone Increasing Digits An integer has monotone increasing digits单调递增数字 if and only if each pair of adjacent digits x and y satisfy x < y. Given an integer n, return the largest number that is less than or equal to n with monotone increa…
阅读更多...
华为OD机试 - 找朋友（Java 2023 B卷 100分）

华为OD机试 - 找朋友（Java 2023 B卷 100分）

目录 专栏导读一、题目描述二、输入描述三、输出描述大白话解释一下就是&#xff1a;1、输入&#xff1a;2、输出&#xff1a;3、说明 四、解题思路五、Java算法源码六、效果展示1、输入2、输出3、说明 华为OD机试 2023B卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专…
阅读更多...
DevExpress WinForms TreeMap组件，用嵌套矩形可视化复杂分层数据

DevExpress WinForms TreeMap组件，用嵌套矩形可视化复杂分层数据

DevExpress WinForms TreeMap控件允许用户使用嵌套的矩形来可视化复杂的平面或分层数据结构。 DevExpress WinForms有180组件和UI库&#xff0c;能为Windows Forms平台创建具有影响力的业务解决方案。同时能完美构建流畅、美观且易于使用的应用程序&#xff0c;无论是Office风…
阅读更多...
vue3 使用simplebar【滚动条】

vue3 使用simplebar【滚动条】

1.下载simplebar-vue npm install simplebar-vue --save2.引入注册 import simplebar from "simplebar-vue"; import simplebar-vue/dist/simplebar.min.css import simplebar-vue/dist/simplebar-vue.jsvue2的版本基础上 【引入注册】 import simplebar from &qu…
阅读更多...
c语言：回文字符串

c语言：回文字符串

题目&#xff1a; 思路&#xff1a; 创建一个字符数组&#xff0c;然后判断字符串长度&#xff0c;用循环&#xff0c;看对应字符是否相等&#xff0c;相等则输出&#xff0c;不相等则将对应字符ascll较大的改成ascll较小的&#xff08;题目要求字典最小的情况&#xff09;。…
阅读更多...
【办公常识_1】写好的代码如何上传？使用svn commit

【办公常识_1】写好的代码如何上传？使用svn commit

首先找到对应的目录 找到文件之后点击SVN Commit
阅读更多...
HT71782 同步集成升压转换器

HT71782 同步集成升压转换器

HT71782是一款高功率、全集成升压转换器&#xff0c;集成16mΩ功率开关管和18mΩ同步整流管&#xff0c;为便携式系统提供G效的小尺寸处理方案。 HT71782采用自适应恒定关断时间峰值电流控制拓扑结构来调节输出电压。在中等到重负载条件下&#xff0c;HT71782工作在PWM 模式。轻…
阅读更多...
Python中列表和字符串常用的数据去重方法你还记得几个？

Python中列表和字符串常用的数据去重方法你还记得几个？

Python中列表和字符串常用的数据去重方法你还记得几个&#xff1f; 1 关于数据去重2 字符串去重2.1 for方法2.2 while方法2.3 列表方法2.4 直接删除法2.5 fromkeys方法 3 列表去重3.1 for方法3.2 set方法13.3 set方法23.4 count方法3.5 转字典法 4 完整代码 1 关于数据去重 关…
阅读更多...
安卓毕业设计基于安卓android微信小程序的培训机构系统

安卓毕业设计基于安卓android微信小程序的培训机构系统

项目介绍 本文以实际运用为开发背景&#xff0c;运用软件工程原理和开发方法&#xff0c;它主要是采用java语言技术和mysql数据库来完成对系统的设计。整个开发过程首先对培训机构管理系统进行需求分析&#xff0c;得出培训机构管理系统主要功能。接着对培训机构管理系统 进行…
阅读更多...
Zoho Bigin和标准版CRM有什么区别？

Zoho Bigin和标准版CRM有什么区别？

Zoho Bigin是Zoho公司推出的一款针对小微企业设计的CRM系统&#xff0c;它与Zoho CRM一脉相承&#xff0c;但更加轻量级&#xff0c;快速帮助小微企业实现数字化销售。下面来说说&#xff0c;Zoho Bigin是什么&#xff1f;它适合哪些企业&#xff1f; 什么是Zoho Bigin&#x…
阅读更多...
基于51单片机设计的人体温度检测与存储系统

基于51单片机设计的人体温度检测与存储系统

一、前言 随着科技的快速发展和人们对健康生活的追求，准确、便捷的体温检测成为日常生活中的重要需求。在当前全球健康环境下，特别是在一些公共场合和家庭中，快速筛查体温以预防疾病传播变得至关重要。基于这一需求，当前设计了基于51单片机的温度检测与存储系统。 传统体…
阅读更多...
单片机调试技巧--栈回溯

单片机调试技巧--栈回溯

在启动文件中修改 IMPORT rt_hw_hard_fault_exceptionEXPORT HardFault_Handler HardFault_Handler PROC; get current contextTST lr, #0x04 ; if(!EXC_RETURN[2])ITE EQMRSEQ r0, msp ; [2]0 > Z1, get fault context from h…
阅读更多...
最新文章

Copyright @ 2022~2023