参星阁 南方嘉木的博客 2026-05-08T05:39:35.066Z https://blog.cancin.cn/ 南方嘉木 Hexo 2026年5月记事 https://blog.cancin.cn/post/b1569420.html 2026-05-01T15:12:12.000Z 2026-05-08T05:39:35.066Z
]]> 没啥好看的 2026年4月记事 https://blog.cancin.cn/post/5e94ff1e.html 2026-04-01T13:51:25.000Z 2026-05-02T07:38:29.708Z
]]> 没啥好看的 基于 Apps Script 为 Zotero 接入更强的 Google 翻译能力 https://blog.cancin.cn/post/6e9377c1.html 2026-03-18T11:38:58.000Z 2026-03-21T13:03:05.764Z 前言

相信很多人都用过 Zotero 的 Translate for Zotero 这个翻译插件，但是它自带的 Google 翻译能力很糟糕，跟网页版的 Google 翻译效果差远了。

所以很多人会使用一些进阶的设置，通过 API 接入各家的大模型，翻译效果会好很多。不过各家大模型能力参差不齐，比如百度、腾讯的翻译能力就一般，机翻味儿很重。各家 API 的调用次数限制也各不相同，像百度的普通翻译接口，每个月前 50 万个字符（约 25 万到 30 万个汉字）是免费的，超过了就需要付费。我先前也接了一个 DeepSeek 的 API，按量收费的，百万 tokens 两毛钱，效果还行，就是不知道为什么速度很慢。

最近看到 Google 云盘有一个 Apps Script 的功能，碰巧它有内置的 LanguageApp.translate() 函数，正好拿来试试。效果非常 amazing 啊，跟网页版 Google 翻译效果完全一样，比 DeepSeek 效果好，速度也更快。我看了一下官方文档，它这个限制是每天 5000 次的请求，每次上限 10000 个字符，相比之下还是蛮划算的，个人用是完全足够了。

部署方法

首先我们打开 Google 云端硬盘，点击左上角“新建 - 更多 - Google Apps Script”，点击创建脚本，我们将这串代码粘贴进去，然后保存。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
function doPost(e) {
  var rawData = e.postData.contents;
  var payload = {};
  var debugMode = false;

  try {
    payload = JSON.parse(rawData);
    // 调试模式
    if (payload.debug === true || payload.debug === "true") {
      debugMode = true;
    }
  } catch (err) {
    return createResponse("JSON 解析错误: " + err.toString());
  }

  // 获取提示词内容 (${sourceText}--->${langTo})
  var fullContent = "";
  if (payload.messages && payload.messages.length > 0) {
    fullContent = payload.messages[payload.messages.length - 1].content;
  }
  var sourceText = "";
  var langTo = "zh-CN";
  if (fullContent.indexOf("--->") !== -1) {
    var splitIndex = fullContent.lastIndexOf("--->");
    sourceText = fullContent.substring(0, splitIndex).trim();
    langTo = fullContent.substring(splitIndex + 4).trim();
  } else {
    sourceText = fullContent;
  }

  // 执行翻译
  var translatedText = "";
  try {
    if (sourceText) {
      translatedText = LanguageApp.translate(sourceText, '', langTo);
    } else {
      translatedText = "未获取到待翻译文本";
    }
  } catch (err) {
    translatedText = "Google 引擎报错: " + err.toString();
  }

  // 返回
  var finalDisplay = translatedText;
  if (debugMode) {
    finalDisplay = "【翻译结果】\n" + translatedText + 
                   "\n\n【Debug 原始请求包】\n" + rawData +
                   "\n\n【解析参数】\n原文: " + sourceText + 
                   "\n目标语言: " + langTo;
  }
  return createResponse(finalDisplay);
}

function createResponse(text) {
  var out = {
    "choices": [{
      "message": {
        "role": "assistant",
        "content": text
      },
      "finish_reason": "stop"
    }]
  };
  return ContentService.createTextOutput(JSON.stringify(out))
    .setMimeType(ContentService.MimeType.JSON);
}

function doGet(e) {
  return ContentService.createTextOutput("服务正常。请在使用 POST 请求。");
}

点击“部署 - 新建部署”，点击左边小齿轮 - web 应用，然后配置参数说明随便填，具有访问权限的用户改成选择 “所有人” (Anyone)，最后点击底部的 “部署”。

部署成功会生成一串地址，我们复制这一串地址，保存待用。

在 Zotero 中使用

打开Zotero的设置 - 翻译 - 翻译服务，拉到最下面有三个自定义GPT选项，密钥不用填，点击配置，把刚才复制的一串地址粘贴到接口里面，模型和温度都不用设置，然后提示词按照下面输入：

1
${sourceText} ---> ${langTo}

这里 ${sourceText} 就是你要翻译的原文，${langTo} 是你要翻译成的语言，然后我们把流式输出关闭，点击保存。

最后还有一点就是把“向GPT/Claude/Gemini服务提供论文标题和摘要”这一设置项取消勾选，当然你要是后面改用其他大模型翻译的话，可以把这个选项再勾回去。

大陆访问

Apps Script 给到的原始链接是不能在大陆访问的，可以给它套一个 Cloudflare，步骤如下：

  1. 登录 Cloudflare 控制台，在左侧菜单栏点击 “Compute” -> “Workers 和 Pages”，点击 “创建应用程序” -> “从 Hello World! 开始”。给你的 Worker 起个新名字或者保持默认，点击 “部署”。
  2. 部署成功后，点击 “编辑代码”，将编辑器里的原有代码全部删掉，替换为下面这段，别忘了修改GOOGLE_URL变量的值为 Apps Script 部署地址。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    export default {
      async fetch(request, env, ctx) {
        const GOOGLE_URL = "这里填你的 Apps Script 部署地址";

        if (request.method === "OPTIONS") {
          return new Response(null, {
            headers: {
              "Access-Control-Allow-Origin": "*",
              "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
              "Access-Control-Allow-Headers": "*",
            },
          });
        }

        const cleanHeaders = new Headers();
        cleanHeaders.set("Content-Type", "application/json");
        let fetchConfig = {
          method: request.method,
          headers: cleanHeaders,
          redirect: "follow"
        };

        if (request.method === "POST") {
          fetchConfig.body = await request.clone().text();
        }

        try {
          const response = await fetch(GOOGLE_URL, fetchConfig);
          const resBody = await response.text();

          return new Response(resBody, {
            headers: {
              "Content-Type": "application/json",
              "Access-Control-Allow-Origin": "*",
            },
          });
        } catch (err) {
          return new Response(JSON.stringify({ error: "Worker Error: " + err.toString() }), { 
            status: 500,
            headers: { "Access-Control-Allow-Origin": "*" }
          });
        }
      },
    };
  3. 返回管理页面，点击上方的 “设置” 选项卡，选择左侧的 “域和路由” (Domains & Routes)，点击 “添加” -> “自定义域”，输入你的域名。
  4. 如果你的域名DNS解析也在 Cloudflare，那么 Cloudflare 会自动帮你配置好 DNS 解析和 SSL 证书。如果不在，则打开你的域名解析服务，添加一条CNAME记录，值就填前面 cloudflare 设置域和路由界面的 workers.dev 的值。

沉浸式翻译插件

沉浸式翻译插件是个非常好用的浏览器插件，有非常多的自定义项，我们也可以把这个翻译服务接入到这个插件里面。

这个插件的{{to}}参数比较特殊，需要做一下映射转换，代码需要替换为下面这个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

function doPost(e) {
  try {
    if (!e || !e.postData || !e.postData.contents) {
      return createResponse("Error: No data received");
    }
    var payload = JSON.parse(e.postData.contents);
    var fullContent = "";
    if (payload.messages && payload.messages.length > 0) {
      fullContent = payload.messages[payload.messages.length - 1].content;
    } else if (payload.prompt) {
      fullContent = payload.prompt;
    } else {
      fullContent = payload.text || "";
    }
    if (!fullContent) return createResponse("Error: Content is empty");
    var sourceText = fullContent;
    var targetLang = "zh-CN"; 
    if (fullContent.indexOf("--->") !== -1) {
      var parts = fullContent.split("--->");
      var langPart = parts.pop().trim();
      if (langPart && langPart.indexOf("{") === -1 && langPart.indexOf("}") === -1) {
        targetLang = langPart;
        sourceText = parts.join("--->").trim();
      }
    }
    var cleanLang = targetLang.toLowerCase().replace(" language", "").trim();
    var langMap = {
      'simplified chinese': 'zh-CN',
      'traditional chinese (taiwan)': 'zh-TW',
      'traditional chinese': 'zh-TW',
      'cantonese': 'yue',
      'english': 'en',
      'japanese': 'ja',
      'korean': 'ko',
      'spanish': 'es',
      'german': 'de',
      'french': 'fr',
      'portuguese': 'pt',
      'russian': 'ru',
      'arabic': 'ar',
      'italian': 'it',
      'thai': 'th',
      'mongolian': 'mn',
      'uyghur': 'ug',
      'zh': 'zh-CN',
      'cn': 'zh-CN',
      'jp': 'ja',
      'kr': 'ko'
    };
    targetLang = langMap[cleanLang] || targetLang;
    var translatedText = LanguageApp.translate(sourceText, '', targetLang);
    return createResponse(translatedText);
  } catch (err) {
    return createResponse("GAS Crash: " + err.toString() + " (Target: " + targetLang + ")");
  }
}
function createResponse(text) {
  var response = {
    "choices": [{
      "message": { "role": "assistant", "content": text },
      "finish_reason": "stop"
    }]
  };
  return ContentService.createTextOutput(JSON.stringify(response))
                       .setMimeType(ContentService.MimeType.JSON);
}
function doGet(e) {
  return ContentService.createTextOutput("API 服务已就绪。")
                       .setMimeType(ContentService.MimeType.TEXT);
}

提示词直接换成{{text}}--->{{to}}即可。

]]> <h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>相信很多人都用过 Zotero 的 Translate 2026年3月记事 https://blog.cancin.cn/post/bc48e467.html 2026-03-01T15:03:44.000Z 2026-04-04T14:01:13.342Z
]]> 没啥好看的 2026年2月记事 https://blog.cancin.cn/post/538a8f59.html 2026-02-01T05:38:27.000Z 2026-03-18T12:39:07.460Z
]]> 没啥好看的 2026年1月记事 https://blog.cancin.cn/post/b8bd345a.html 2026-01-01T15:04:41.000Z 2026-03-18T12:39:13.040Z
]]> 没啥好看的 【CVPR2025】低光图像增强HVI-CIDNet https://blog.cancin.cn/post/98e97756.html 2025-10-18T15:53:42.000Z 2026-03-18T12:38:43.473Z

论文标题：HVI: A New Color Space for Low-light Image Enhancement
DOI：https://doi.org/10.48550/arXiv.2502.20272
代码地址：https://github.com/Fediory/HVI-CIDNet
收录：CVPR2025

研究背景

在光照不足条件下拍摄的图像通常存在亮度不足、对比度低、细节模糊及噪声干扰等问题，通过 LLIE（低光图像增强）算法可以使其更接近人眼在正常光照下的感知效果，满足后续视觉任务（如目标检测、语义分割）的高质量输入需求。

LLIE 算法主要面临以下难点：

  • 光照不足导致的细节丢失：低光图像中暗部区域信息模糊，难以恢复真实细节。
  • 噪声干扰：在增强亮度时，图像噪声（如高斯噪声、椒盐噪声）会被放大，影响视觉质量和算法鲁棒性。
  • 动态范围限制：相机传感器在低光下的动态范围有限，导致图像过暗或过亮区域失真。
  • 色彩失真：增强过程中可能破坏图像原有的色彩平衡，出现色偏或伪影。

颜色空间

常见的 LLIE 算法多基于 sRGB 空间或者 HSV 空间。

sRGB（Standard Red Green Blue）即标准红、绿、蓝颜色空间，代表算法有 ZeroDCE、EnlightenGAN。缺点是亮度与 RGB 三通道色彩强耦合（high color sensitivity），牵一发而动全身，在增强的过程中容易导致失真，比如调整亮度引发颜色偏移，优化颜色导致亮度失真。

HSV（Hue Saturation Value）即色相、饱和度、明度颜色空间，代表算法有 RetinexNet、CoLIE。缺点是虽然解耦了亮度与色彩，但同时引入了红色不连续噪声和黑色平面噪声，这两种噪声会在以红色为主或极暗图像的增强过程中产生严重的伪影。

YCbCr，即亮度轴（Y）+反射色平面（CbCr）。Y 轴仍与 CbCr 平面存在部分耦合，从而导致严重的色偏。

HVI（Horizontal/Vertical-Intensity）

HVI 是基于 HSV 优化而来，其核心是确保相似颜色具有更小的欧氏距离，通过两大技术解决 HSV 噪声问题：

  • 一是极化 HS 映射，通过极坐标约束红色坐标距离，来消除红色不连续噪声。
  • 二是可学习压缩函数 C_k，动态压缩低光区域的强度分布，来消除黑色平面噪声。

极化 HS 映射

首先根据 Max-RGB 理论计算每个像素的 Intensity，构建 I-map，这里可以反映图像的全局光照水平。

然后根据 I-map，可以计算出 S-map 和 H-map。

这里不难发现，在 HSV 空间中，红色在色相端点（h=0和h=6）上间断，进而导致增强后出现红色不连续噪声。因此我们只需要将色相轴 h 极化，将其映射到两个新的正交分量 h=cos⁡(πh/3)、v=sin⁡(πh/3)，即可使得红色在 h-v平面连续。

C_k 函数

针对黑色平面噪声问题，需要缩小低光区域的同时保留高光区域。但是，这个压缩程度在不同的数据集和网络中是不同的。因此，这里就需要一个可信息的自适应的压缩函数 C_k。

其中，k是一个可训练参数，用于控制暗色点密度；ε=10^(-8) 避免根号里为0，用于避免梯度爆炸。

本质上，C_k 起到半径映射函数的作用，较小的 C_k 对应较小的半径或较低的强度值。因此，随着 C_k 的减小，暗色点会聚集在一起。

最后整合色彩与强度信息，定义水平 图和垂直 图为：

其中，h∈H，v∈V，⨀ 表示元素级乘法。、、I_max 可以拼接形成 HVI 图像。

CIDNet（Color and Intensity Decoupling Network）

即颜色和强度解耦网络，用于分别对 HVI 空间中的 HV 平面和 I 轴信息进行建模。

CIDNet 整体分为三个步骤——HVI 变换、双分支增强网络、感知逆 HVI 变换（PHVIT）。

首先通过 HVI 变换将 sRGB 图像映射到 HVI 颜色空间，有效分离亮度与色彩，得到 Intensity Map 和 HV Color Map。

随后在 HVI 空间中通过双分支网络进行增强，其中 HV 分支用来抑制暗部的噪声和色度，利用 I 分支来估计整个图像的照度，进行亮度增强。两分支通过 LCA 模块进行交互，避免全局色偏。

最后通过感知逆 HVI 变换（PHVIT）将增强结果映射回 sRGB 空间，得到无色偏、无伪影的增强图像。

可以看到，中间这个双分支网络基于 Unet 架构构建，包含1个编码器和1个解码器，有3个下采样层和3个上采样层，每层都配备了1个轻量交叉注意力（LCA）模块，以及多个跳跃连接。

这样的设计打破了单分支自注意力局限，利用 “光照与噪声负相关” 特性，引导 HV-branch 针对性降噪（高光区少降噪、低光区多降噪），同时将 HV-branch 降噪后的信息反馈给 I-branch，避免亮度过度增强。

双分支分别优化色彩与强度，LCA 模块实现特征互导，确保色彩降噪与亮度增强同步优化，避免各自为战导致的色偏或亮度伪影。

损失函数

为了对 CIDNet 的训练提供全面监督，我们从两个关键角度指导增强过程，包括 sRGB 空间中的真实值（GroundTruth）和 HVI 空间中的 HVI 图。

其中，λ 是一个加权超参数，用于平衡两个不同颜色空间中的损失。

该设计以双空间混合框架打通 “低光噪声抑制” 与 “像素细节保留” 的协同路径，以多损失项组合覆盖 “客观误差 - 结构 - 边缘 - 感知” 的全维度监督需求。

数据集

采用了七个常用的低光图像增强基准数据集进行评估，包括 LOLv1、LOLv2、DICM、LIME、MEF、NPE 和 VV。（DICM、LIME、MEF、NPE 和 VV 为非配对数据集）

同时还在两个极端数据集上进行了进一步的实验，分别是 SICE（包含混合测试集和梯度测试集）和 SID（索尼全暗）。

实验效果

HVI插件

HVI 作为插件使用，显著提升 SOTA 算法性能。

消融实验

总结

  • 实验证明 HVI + CIDNet 在 10 个数据集上超越现有 SOTA 方法，同时参数量小（1.88M）且计算量低（7.57 GFLOPs）；
  • 跨方法泛化：HVI 与不同网络架构兼容，可将其作为插件模块使用，能解决各类方法的共性噪声问题；
  • 跨任务泛化：HVI 不仅适用于 LLIE，还可扩展至低光去模糊、图像降噪，证明其在低层级视觉任务中的通用价值。

不足

  • 未探索比正弦函数更优的 C_k 表达式；
  • 未验证 HVI 在目标检测、分割等高层视觉任务的适用性；
  • 仅采用监督训练，未探索无监督或半监督范式。

复现

readme 文件给的环境配置有问题，这里给出我复现的软硬件配置。

硬件：

  • CPU：Intel Core i9-14900K
  • 显卡：RTX 4090 24G
  • 内存：32G

软件：

  • Anaconda：24.3
  • Python：3.10
  • CUDA：12.4

修改 requirements.txt 为以下版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
arch==5.3.1
image_quality==1.2.7
lpips==0.1.4
matplotlib==3.5.3
numpy==1.24.3
opencv_contrib_python==4.7.0.72
opencv-python==4.7.0.72
Pillow==9.5.0
scipy==1.9.3
thop==0.1.1.post2209072238
torch==2.4.0
torchvision==0.19.0
torchaudio==2.4.0
tqdm==4.65.0
einops==0.6.1
gradio==3.41.2
huggingface_hub==0.19.4
safetensors==0.4.2
]]> <blockquote class=""><p><strong>论文标题</strong>：HVI: A New Color Space for Low-light Image 侧边栏组件 - 年月历文章归档卡片 https://blog.cancin.cn/post/7be4d94d.html 2025-05-21T05:01:16.000Z 2025-07-01T04:41:35.917Z 预览

年月历文章归档卡片

相比自带卡片占用更小的展示面积，能查看所有月份的文章数量，点击年份可以查看对应年份的所有文章，左右两个按钮可以切换年份。

实现

  1. 找到\themes\butterfly\scripts\helpers\aside_archives.js，注释掉所有原有的代码，替换成下面代码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    'use strict'
    hexo.extend.helper.register('aside_archives', function (options = {}) {
    const { config } = this
    const archiveDir = config.archive_dir
    const { timezone } = config
    const lang = toMomentLocale(this.page.lang || this.page.language || config.language)
    let { format } = options
    const type = options.type || 'monthly'
    const order = options.order || -1
    const compareFunc = type === 'monthly'
        ? (yearA, monthA, yearB, monthB) => yearA === yearB && monthA === monthB
        : (yearA, monthA, yearB, monthB) => yearA === yearB
    let result = ''
    if (!format) {
        format = type === 'monthly' ? 'MMMM YYYY' : 'YYYY'
    }
    const posts = this.site.posts.sort('date', order)
    if (!posts.length) return result
    const data = []
    let length = 0
    posts.forEach(post => {
        // Clone the date object to avoid pollution
        let date = post.date.clone()
        if (timezone) date = date.tz(timezone)
        const year = date.year()
        const month = date.month() + 1
        const lastData = data[length - 1]
        if (!lastData || !compareFunc(lastData.year, lastData.month, year, month)) {
        if (lang) date = date.locale(lang)
        const name = date.format(format)
        length = data.push({
            name,
            year,
            month,
            count: 1
        })
        } else {
        lastData.count++
        }
    })
    // 按年份分组
    const groupedData = data.reduce((acc, { name, year, month, count }) => {
        if (!acc[year]) {
        acc[year] = { year, sum: 0, data: [] }; // 初始化年份条目
        }
        acc[year].sum += count; // 累加年份的总文章数
        acc[year].data.push({ name, month, count }); // 将月份数据加入对应年份
        return acc;
    }, {});
    // 转换为目标数组格式
    const newData = Object.values(groupedData);
    result += `<div class="item-headline"><i class="fas fa-archive"></i><span>${this._p('aside.card_archives')}</span>`
    result += '</div>'
    result += `<div class="card-archive-calendar">
        <div class="card-archive-calendar-head">
        <button class="card-archive-calendar-left`
    if (newData.length === 1) result += ' no-event'
    result +=
        `" onclick="ctrl.card_archive_calendar_prev()">
            <i class="fas fa-angle-left"></i>
        </button>
        <div class="card-archive-calendar-center">
            <div class="card-archive-calendar-years" style="transform: translateX(0px);">`
    for (let i = 0; i < newData.length; i++) {
        let url = `${archiveDir}/${newData[i].year}/`
        result +=
        `<a class="card-archive-calendar-year-item" href="${this.url_for(url)}">
                <span class="card-archive-calendar-year">${newData[i].year}</span>
                <span class="card-archive-calendar-year-count">[${newData[i].sum}]</span>
                </a>`
    }
    result +=
        `</div>
        </div>
        <button class="card-archive-calendar-right no-event" onclick="ctrl.card_archive_calendar_next()">
            <i class="fas fa-angle-right"></i>
        </button>
        </div>
        <div class="card-archive-calendar-body">
        <div class="card-archive-calendar-pages" style="transform: translateX(0px);">`
    for (let i = 0; i < newData.length; i++) {
        let item = newData[i]
        let m = ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']
        let k = item.data.length - 1
        result +=
        `<div class="card-archive-calendar-page">`
        for (let j = 0; j < 12; j++) {
        let c = 0
        if (k >= 0 && j == item.data[k].month - 1) {
            c = item.data[k].count
            let url = `${archiveDir}/${item.year}/`
            if (type === 'monthly') {
            if (item.data[k].month < 10) url += '0'
            url += `${item.data[k].month}/`
            }
            result +=
            `<a class="card-archive-calendar-month-item" href="${this.url_for(url)}">`
            k--
        } else {
            result +=
            `<a class="card-archive-calendar-month-item no-link">`
        }
        result +=
            `<span class="card-archive-calendar-month">${m[j]}</span>
                    <span class="card-archive-calendar-month-count">${c}篇</span>
                </a>`
        }
        result +=
        `</div>`
    }
    result +=
        `</div>
        </div>
        </div>`
    return result
    })
    const toMomentLocale = function (lang) {
    if (lang === undefined) {
        return undefined
    }
    // moment.locale('') equals moment.locale('en')
    // moment.locale(null) equals moment.locale('en')
    if (!lang || lang === 'en' || lang === 'default') {
        return 'en'
    }
    return lang.toLowerCase().replace('_', '-')
    }

  2. 补充逻辑函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    var ctrl = {
        card_archive_calendar_prev() {
            let a = document.querySelector(".card-archive-calendar-years")
            let b = document.querySelector(".card-archive-calendar-pages")
            let count = a.childElementCount
            let prev = document.querySelector(".card-archive-calendar-left")
            let next = document.querySelector(".card-archive-calendar-right")
            let t = a.style.transform
            if (t) {
                let m = parseFloat(t.match(/translateX\((-?\d+\.?\d*)(px|%)?\)/)[1])
                let n = m / 100
                if (n > 0 && n < count - 2) {
                    a.style.transform = "translateX(" + 100 * (n+1) + "px)"
                    b.style.transform = "translateX(" + 298 * (n+1) + "px)"
                } else if (n == count - 2) {
                    a.style.transform = "translateX(" + 100 * (n+1) + "px)"
                    b.style.transform = "translateX(" + 298 * (n+1) + "px)"
                    prev.classList.add("no-event")
                } else if (n == 0) {
                    a.style.transform = "translateX(" + 100 + "px)"
                    b.style.transform = "translateX(" + 298 + "px)"
                    if (count == 2) {
                        prev.classList.add("no-event")
                        next.classList.remove("no-event")
                    } else if (count > 2) {
                        next.classList.remove("no-event")
                    }
                }
            }
        },

        card_archive_calendar_next() {
            let a = document.querySelector(".card-archive-calendar-years")
            let b = document.querySelector(".card-archive-calendar-pages")
            let count = a.childElementCount
            let prev = document.querySelector(".card-archive-calendar-left")
            let next = document.querySelector(".card-archive-calendar-right")
            let t = a.style.transform
            if (t) {
                let m = parseFloat(t.match(/translateX\((-?\d+\.?\d*)(px|%)?\)/)[1])
                let n = m / 100
                if (n > 1 && n < count - 1) {
                    a.style.transform = "translateX(" + 100 * (n-1) + "px)"
                    b.style.transform = "translateX(" + 298 * (n-1) + "px)"
                } else if (n == count - 1) {
                    a.style.transform = "translateX(" + 100 * (n-1) + "px)"
                    b.style.transform = "translateX(" + 298 * (n-1) + "px)"
                    prev.classList.remove("no-event")
                } else if (n == 1) {
                    a.style.transform = "translateX(0px)"
                    b.style.transform = "translateX(0px)"
                    next.classList.add("no-event")
                }
            }
        }
    }

  3. 添加样式代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    .card-archive-calendar-head {
        width: 100%;
        display: flex;
        align-items: center;
        justify-content: space-between;
        padding: 5px;
    }

    .card-archive-calendar-head button {
        height: 30px;
        width: 30px;
        color: var(--font-color);
        transition: .3s;
    }

    .card-archive-calendar-head button,
    .card-archive-calendar-center {
        background: var(--gavin-widget-bg1);
        border-radius: 8px;
    }

    .card-archive-calendar-head button:hover,
    .card-archive-calendar-year-item:hover {
        background: var(--gavin-widget-bg2);
        color: var(--dis-f-0);
    }

    .card-archive-calendar-year-item span,
    .card-archive-calendar-month-item span {
        line-height: 1.3;
    }

    .card-archive-calendar-center {
        height: 30px;
        width: 100px;
        display: flex;
        overflow: hidden;
        justify-content: flex-end;
    }

    .card-archive-calendar-years {
        display: flex;
        flex-direction: row;
        transition: .3s ease;
    }

    .card-archive-calendar-year-item {
        display: flex;
        align-items: center;
        justify-content: center;
        width: 100px;
    }

    .card-archive-calendar-year {
        font-weight: bold;
    }

    .card-archive-calendar-year-count {
        margin-left: 5px;
    }

    .card-archive-calendar-year-count,
    .card-archive-calendar-month-count {
        font-size: 85%;
        font-weight: bold;
        opacity: .4;
    }

    .card-archive-calendar-body {
        height: 100%;
        width: 100%;
        display: flex;
        overflow: hidden;
        justify-content: flex-end;
        padding: 5px 0;
    }

    .card-archive-calendar-pages {
        display: flex;
        flex-direction: row;
        transition: .3s ease;
    }

    .card-archive-calendar-page {
        height: 100%;
        width: calc(298px - 10px);
        display: flex;
        flex-direction: row;
        flex-wrap: wrap;
        gap: 10px;
        margin: 0 5px;
    }

    .card-archive-calendar-month-item {
        display: flex;
        flex-direction: column;
        align-items: center;
        justify-content: center;
        width: calc((100% - 30px) / 4);
        height: 50px;
        cursor: pointer;
        background: var(--gavin-widget-bg1);
        border-radius: 8px;
        font-weight: bold;
    }

    .card-archive-calendar-month-item:hover {
        background: var(--gavin-nav-hover);
        color: #fff;
    }

    .card-archive-calendar-head button.no-event,
    .card-archive-calendar-month-item.no-link {
        opacity: 0.3;
        pointer-events: none;
    }

]]> 替代Butterfly原有的Archive卡片，功能更加强大。 Twikoo评论自定义用户专属头衔 https://blog.cancin.cn/post/5c6ff12b.html 2025-05-08T03:37:37.000Z 2025-07-01T04:41:55.054Z 馋 Artalk 的自定义专属头衔很久了，但是 Twikoo 迟迟不开发这个功能，就看看能不能自己改改。

找到 twikoo.all.min.js 源代码，搜索e.comment.master快速定位到大概位置，这块是个叫 3072 的函数，看了一下猜测应该是生成评论 DOM 结构用的。

  • e.comment.master是判断该评论是否是博主的评论；

  • e.comment.nick是该评论用户的昵称；

  • e.comment.mailMd5是该评论用户的邮箱加密后的哈希值。

那么我就可以根据这个e.comment.nick或者e.comment.mailMd5标记具体的用户了，考虑到有时候用户容易输错昵称或者经常改名，所以我用的是邮箱哈希来标记。

我打印了一下评论用户邮箱的哈希，确定是采用的普通的 MD5 加密或者 SHA256 加密，我翻阅了一下 Twikoo 的更新日志，具体是 1.6.36 版本之前用的是 MD5 加密，之后用的就是 SHA256 加密。

那么如果你知道你好友的评论邮箱（一般都是QQ邮箱），那就可以算出来他的评论的邮箱哈希了。

修改 twikoo.all.min.js，并在主题设置文件 _config.butterfly.yml 中 CDN > option > twikoo 处引入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// ......
- e.comment.master ? t("span", {
-     staticClass: "tk-tag tk-tag-green"
- }, [e._v(e._s(e.config.MASTER_TAG || e.t("COMMENT_MASTER_TAG")))]) : e._e(), e._v(" "),
+ e.comment.master ? t("span", {
+     staticClass: "tk-tag tk-tag-green"
+ }, [e._v(e._s(e.config.MASTER_TAG || e.t("COMMENT_MASTER_TAG")))]) : (function() {
+     const userTags = {
+         '邮箱哈希1': '自定义头衔1',
+         '邮箱哈希2': '自定义头衔2'
+     };
+     const tag = userTags[e.comment.mailMd5];
+     return tag ? t("span", {
+         staticClass: "tk-tag tk-tag-purple"
+     }, [e._v(e._s(tag))]) : t("span", {
+         staticClass: "tk-tag tk-tag-grey"
+     }, [e._v(e._s('道友'))]);
+ })(), e._v(" "),

e.comment.top ? t("span", {
    staticClass: "tk-tag tk-tag-red"
}, [e._v(e._s(e.t("COMMENT_TOP_TAG")))]) : e._e(), e._v(" "), 
// ......

当然tk-tag-purple的样式需要自己补充一下。

效果如下：

自定义头衔示例

]]> 自定义用户专属头衔 使用Vercel部署百度统计API https://blog.cancin.cn/post/71b7da78.html 2025-04-18T12:34:26.000Z 2025-07-29T01:16:40.056Z 前言

51La挂了好久好久了，之前备考，一直没修，最近看百度统计 PV 数据达到了开通 API 的标准，正好得空给它换成了百度统计。因为有跨域问题，所以还是做了个 API 从后端获取。

本来想直接用下面洪哥这篇文章的代码，不过是用 PHP 写的，针对 docker 环境部署，采用 json 文件存储 tokens 数据，而 vercel 的文件都是只读的，所以还是得改用数据库存储 tokens 数据。

基于百度统计实现显示近一年的pv、uv数据的API搭建

https://blog.zhheo.com/p/2046d684.html

From —— 张洪Heo

引自外站地址，不确保可用性和安全性

大体思路和之前三篇文章类似，采用 supbase 数据库存储 access_token、refresh_token 和 tokens 时效信息，当 tokens 时间超过20天（百度统计官方文档规定 access_token 有效期30天），服务端自动通过百度统计 API 刷新 tokens 数据。

前端采用 localStorage 缓存访问数据，有效期3小时，初次获取数据后将存入缓存，有效期内直接从缓存读取，超时则重新拉取，同时刷新缓存。

首先阅读百度账号接口说明，手动依次获取 siteId、code、access_token、refresh_token。可通过Tongji API调试工具调试。

注意 Vercel 部署时添加 API_KEY、SECRET_KEY、SITE_ID 到环境变量。

代码

后端 index.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
// 导入所需包和模块
const axios = require('axios');
const express = require('express');
const {
  startOfWeek,
  startOfMonth,
  startOfYear,
  differenceInDays, 
  format,
} = require('date-fns');// 时间处理依赖包
const path = require('path');
const app = express();
app.use(function(req, res, next) {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  next();
});
// 创建 Express 应用程序
app.use(express.json());
// 连接数据库
const { createClient } = require('@supabase/supabase-js');
const supabaseUrl = '你的数据库地址';
const supabaseKey = process.env.SUPABASE_KEY;
const supabase = createClient(supabaseUrl, supabaseKey);

// 百度统计变量
const apiKey = process.env.API_KEY || '';
const secretKey = process.env.SECRET_KEY || '';
const siteId = process.env.SITE_ID || '';
let access_token = null;
let refresh_token = null;

// 百度统计接口
app.get('/baidupv', async (req, res) => {
  const { data: tokenData, error } = await supabase
    .from('PVTokens')
    .select()
    .eq('name', 'baidu')
  if (error) {
    console.error('Database Error:', error);
    res.json({ error: 'database error' })
  } else {
    const today = new Date();
    const todayFormat = format(today, 'yyyyMMdd');
    let latestTime = tokenData[0].time; // Tokens 生成时间
    let passTime = differenceInDays(today, latestTime); // Tokens 时效
    let data = {
        today_uv: null,
        today_pv: null,
        yesterday_uv: null,
        yesterday_pv: null,
        last_week_uv: null,
        last_week_pv: null,
        last_month_uv: null,
        last_month_pv: null,
        last_year_uv: null,
        last_year_pv: null,
        total_uv: null,
        total_pv: null
    };
    if (passTime < 20) { // 小于 20 天直接返回
      access_token = tokenData[0].tokens.access_token;
    } else {
      refresh_token = tokenData[0].tokens.refresh_token;
      const newTokens = await refreshAccessToken(apiKey, secretKey, refresh_token); // 大于 20 天重新获取 tokens
      access_token = newTokens.access_token;
      refresh_token = newTokens.refresh_token;
      const { data, error } = await supabase // 刷新数据库 tokens 信息
        .from('PVTokens')
        .update({ tokens: {"access_token": access_token, "refresh_token": refresh_token}, time: today })
        .eq('name', 'baidu')
        .select()
    }
    const totalData = await getData('20250403', todayFormat, 'pv_count,visitor_count', access_token, siteId);
    if (totalData && totalData.result && totalData.result.items && totalData.result.items[1]) {
        const dataPoints = totalData.result.items[1];
        data.today_pv = dataPoints.slice(-2)[1][0]; // 今日访问量
        data.today_uv = dataPoints.slice(-2)[1][1]; // 今日访客量
        data.yesterday_pv = dataPoints.slice(-2)[0][0]; // 昨日访问量
        data.yesterday_uv = dataPoints.slice(-2)[0][1]; // 昨日访客量
        const daysPassedInWeek = differenceInDays(today, startOfWeek(today, { weekStartsOn: 1 })); // 计算本周已过天数（周一作为周起始日）
        const daysPassedInMonth = differenceInDays(today, startOfMonth(today)); // 计算本月已过天数
        const daysPassedInYear = differenceInDays(today, startOfYear(today)); // 计算本年已过天数
        dataPoints.slice().reverse().forEach((point, index) => { // 倒序遍历，计算时间
            var pv = point[0] == "--" ? 0 : point[0];
            var uv = point[1] == "--" ? 0 : point[1]; // 访问量为0时API返回的是"--"，需要替换成0
            data.total_pv += pv; // 累加页面访问量
            data.total_uv += uv; // 累加页面访客量
            if(index < daysPassedInWeek) {
                data.last_week_pv += pv; // 累加本周访问量
                data.last_week_uv += uv; // 累加本周访客量
            }
            if(index < daysPassedInMonth) {
                data.last_month_pv += pv; // 累加本月访问量
                data.last_month_uv += uv; // 累加本月访客量
            }
            if(index < daysPassedInYear) {
                data.last_year_pv += pv; // 累加本年访问量
                data.last_year_uv += uv; // 累加本年访客量
            }
        });
    }
    res.json(data)
  }
})

// 百度统计获取 PV 数据
async function getData(startDate, endDate, metrics, accessToken, siteId) {
  const url = "https://openapi.baidu.com/rest/2.0/tongji/report/getData";
  const params = new URLSearchParams({
      access_token: accessToken,
      site_id: siteId,
      method: 'overview/getTimeTrendRpt',
      start_date: startDate,
      end_date: endDate,
      metrics: metrics
  });
  try {
      const response = await axios.get(url, { params });
      return response.data;
  } catch (error) {
      console.error('Error fetching PV data:', error);
      throw new Error('Error fetching PV data.');
  }
}

// 百度统计刷新 Access Token
async function refreshAccessToken(apiKey, secretKey, refreshToken) {
  const url = "https://openapi.baidu.com/oauth/2.0/token";
  const params = new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: refreshToken,
      client_id: apiKey,
      client_secret: secretKey
  });
  try {
      const response = await axios.get(url, { params });
      return response.data;
  } catch (error) {
      console.error('Error refreshing access token:', error);
      throw new Error('Error refreshing access token.');
  }
}

// 启动服务器
const server = app.listen(process.env.PORT || 3000, () => {
  const port = server.address().port;
  console.log(`Server is running on port ${port}`);
});

前端代码

可用 script 嵌入 about.pug

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
let latestTime = (new Date).getTime();
if (localStorage.getItem('BlogPV') == null || localStorage.getItem('BlogPVTime') == null || (latestTime - localStorage.getItem('BlogPVTime')) > 10800000) { // 3小时时效
    fetch('https://apis.cancin.cn/baidupv')
        .then(response => response.json())
        .then(data => {
            localStorage.setItem('BlogPV', JSON.stringify(data));
            localStorage.setItem('BlogPVTime', latestTime);
            statisticShow(data);
            console.log('BlogPV数据已更新');
        })
        .catch(error => {
            console.error('获取 PV 失败:', error);
        });
} else {
    BlogPV = JSON.parse(localStorage.getItem('BlogPV'));
    statisticShow(BlogPV);
    console.log('BlogPV数据已过时'+(latestTime - localStorage.getItem('BlogPVTime'))+'ms');
}
function statisticShow(BlogPV) {
    document.getElementById('statistic').innerHTML = `
    <div>
    <span>今日人数</span>
    <span>${BlogPV.today_uv}</span>
    </div>
    <div>
    <span>今日访问</span>
    <span>${BlogPV.today_pv}</span>
    </div>
    <div>
    <span>本周访问</span>
    <span>${BlogPV.last_week_pv}</span>
    </div>
    <div>
    <span>本月访问</span>
    <span>${BlogPV.last_month_pv}</span>
    </div>
    <div>
    <span>总访问量</span>
    <span>${BlogPV.total_pv}</span>
    </div>
    `
}
]]> <h2 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h2><p>51La挂了好久好久了，之前备考，一直没修，最近看百度统计 电脑数据迁移记录 https://blog.cancin.cn/post/66be8c26.html 2025-04-07T23:15:21.000Z 2025-07-01T04:25:40.510Z 前言

最近换了一台新电脑——ThinkBook14+ 2025款，选的是顶配的 Ultra9285H 32G + 1T 配置，这台电脑最大的优点就是接口极其丰富，拥有1个HDMI2.1 FRL、2个USB3.2 GEN1、1个雷电4、1个全功能Type-C、1个RJ45网口，另外还有隐藏式的USB2.0可以容纳鼠标接收器，以及可用于外接显卡的OCulink显卡接口。

屏幕方面这款电脑采用的是IPS雾面屏，虽然最近各大厂商都在推OLED屏，但手机上烧屏等问题尚且未得到彻底解决，笔记本上OLED只能说是弊大于利。触控板采用苹果华为类似的全域压感方案，实际效果不如苹果华为，功能也不如他们丰富，但比传统的触控板手感还是好上不少。摄像头支持物理防窥，另外有一组TOF镜头，支持Windows Hello，加上集成指纹识别的电源模块，在解锁这一块算是拉满了。电池方面容量为85Wh，得益于英特尔这一代CPU的新架构，续航比2024款提升了2个小时左右（当然还是不如荣耀，这也体现出传统厂商的优化真的是一言难尽，全靠英特尔发挥是吧？）。

至于缺点，也有几项。一是它虽然拥有2个M.2 2280硬盘接口，其中从盘还是PCIe 5.0，但是原装的却是2242的硬盘，难以理解。二是性能释放中规中矩，在其他厂商都给到80W性能释放的情况下，这台机子依然只给到了70W的性能释放。三是整机重量偏重，1.56kg的重量在轻薄本里算是最重的一档了，甚至比上一代还略重了一点。最后第四点，相比于2024款，2025款砍掉了OCulink接口的热插拔功能，非常可惜。

虽然缺点一堆，但最近几年的电脑市场不景气，也实在没什么特别出色的产品了。一是英特尔和AMD轮流挤牙膏，二是传统PC厂商啃老本不思进取，三是小米、荣耀等新势力厂商尚待发展，华为还受到了制裁，甚至可能都没有下一代Windows产品了。所以PC的现状就是，传统厂商的产品软件生态和系统优化一塌糊涂，新势力厂商的产品除了软件生态和系统优化一无是处。我很希望有两者优点结合的产品，但是现在就是没有，未来或许可以寄希望于那些新势力厂商，但需要时间。我最早用的就是联想，后来转到华为被其便捷的生态吸引，现在又选择了传统厂商联想的ThinkBook，也是想试试从自身入手，看看能否摆脱生态的粘性。

到手用图吧工具箱验机，三星的内存，华星光电的屏幕，亿联的固态，英特尔的BE200网卡，算是还行。硬盘我另外买了一块2T的致态TiPlus7100，找售后给我把原装的亿联替换掉，亿联盘格式化后装在了从盘的位置。联想的售后加装硬盘是要60元，重装系统80元，一共140元，这一点之前旧电脑去华为售后的时候是免费的。

硬件准备完毕后面就是软件和数据迁移。

系统账户

系统用户名一定不能含有中文和空格！

从售后回来，突然想起来之前店员让我设置姓名的时候，那个姓名应该是C盘用户目录下的文件夹名，我输入的名字有空格，感觉有点不妥，记得有些软件如果路径中有中文和空格会报错，所以以防万一我又把电脑重置了一遍。重装后联想全家桶一个不剩哈哈哈。

重置电脑后，在连接网络之前按shift+fn+F10打开cmd，输入oobe\bypassnro回车，系统会重新启动，在联网的页面点击“我没有Internet连接”即可无网络进入Windows，后面就会使用本地账户登录，出现让你输入姓名的页面，这时输入自定义的姓名（最好全英文）就是以后C盘下面我的用户文件夹名，比如我姓名设置是Gavin，我的用户文件夹路径就是C:\Users\Gavin。

如果不使用本地账户，而用微软账户登录，那么用户文件夹名会由系统根据你微软账号的邮箱名自动生成，比如我微软账户是123456789@qq.com，用户文件夹名就会被系统自动设置为12345，路径C:\Users\12345。

本地账户登录后，检查完电脑没有问题，也可以继续登录绑定微软账户。

检查设备加密，确保处于关闭状态！

进入系统后，检查一下设置 > 隐私和安全性 > 设备加密，发现它默认开启了设备加密，这里需要将其关闭，否则它不知道什么时候就会给你把硬盘锁了，忘了 BitLocker 密钥的话可就麻烦了。

Office激活

我登录微软账户后，打算领取电脑自带的Office 2024，但由于这个微软账户之前在旧电脑上领取过Office 2016，所以在新电脑上它又自动给我转成了2016，而2024始终无法领取。

所以新电脑如果使用以前绑定过Office的微软账户登录，就需要注意使用下面的方法。

拨打联想客服，先尝试注册新的微软账号领取Office 2024，但进入Office后并没有自动领取，而是显示试用状态。又换了一个客服，提供了一个Office修复工具，终于成功领取了。

首先如果你没有Office2024，可以通过官方链接下载安装包并安装，然后将电脑连接到手机热点，打开网络和Internet > 高级网络设置 > Internet选项 > 高级，勾选 TLS 1.0 和 TLS 1.1，然后打开文章链接，滑动到最底部，点击下载附件 cssemerg97275.rar ，解压后双击运行里面的 cssemerg97275.diagcab 文件，按提示操作即可。然后重启电脑，进入微软商店 > 库 > 设备附带重新领取Office即可。

QQ和微信迁移

由于QQ和微信最近一年都改成了全新的架构，所以在我的旧电脑上存在两种QQ和两种微信。本来在新QQ是看不到旧QQ的聊天记录的，后来在新QQ点击导入历史消息后就能在新QQ上看到所有历史消息了，打开文件管理器，进入QQ的数据存储文件夹，里面同时存在新旧QQ的文件，看来是系统自动合并了，旧QQ彻底弃用。至于微信，则是新旧文件夹分开存储，文件结构也完全不同，乱成一锅粥。

微信文件夹乱成这个样子，直接复制迁移估计不太行，但是，好在电脑端的微信一直有个弊端，那就是它只要不登陆，就不会接收聊天消息，哪怕手机端聊的再多，电脑微信登录后也不会自动同步手机端的聊天消息，所以这就导致电脑端微信如果不是天天登录，那聊天记录就总是断断续续的。而手机端对应有个优点，哪怕聊天记录再久远，它也不会像QQ那样过期，而且聊天消息肯定不会遗漏，所以手机端的聊天记录反而是最全的。于是微信的迁移就简单多了，直接点击手机微信上的设置 > 聊天 > 聊天记录迁移与备份 > 迁移，迁移到新电脑就可以了。

不同于微信，QQ的聊天记录不会断断续续，而手机端QQ聊天记录还经常漫游过期删除，所以电脑端聊天记录是最全的。QQ本来我也打算用它自带的迁移工具进行迁移，先从旧电脑迁移到手机，再从手机迁移到新电脑即可。但是，QQ的迁移工具一直连接不上我的手机，无论是更换网络连接，还是统一升级到最新版本，都无法连接，直接卡死在了第一步。没办法，只能尝试直接复制整个文件夹到新电脑，好在QQ新版旧版都在一个目录下面，比较方便。万幸，直接复制过来后QQ一切正常，聊天记录也能正常查看。

Hexo博客迁移

Hexo的迁移其实就是重走一遍Hexo的安装过程，也就是说只能重装。但是主题是可以迁移的，直接从旧电脑复制过来即可。

大部分步骤参考这篇文章。

更换电脑后，如何迁移 hexo 博客？

https://www.cnblogs.com/ckern/p/18071752

From —— 博客园@CKern

引自外站地址，不确保可用性和安全性

在重装Hexo之前，首先应该配置环境，也就是Git和Node。

Git安装

首先可以先去下载安装一个VS Code。

进入 git官网 下载 64-bit Git for Windows Setup 安装包，按提示安装，可以参考以下文章。

Git详细安装教程（详解 Git 安装过程的每一个步骤）

https://blog.csdn.net/mukes/article/details/115693833

From —— CSDN@mukes

引自外站地址，不确保可用性和安全性

命令行输入git -v可查看是否安装成功，随后进行用户名和邮箱配置。命令行输入以下代码。

1
2
git config --global user.name "你的用户名"
git config --global user.email "你的邮箱"

接着执行以下命令生成 SSH 公钥，用于连接 Github。

1
ssh-keygen -t rsa -C "你的邮箱"

进入C:\Users\Gavin\.ssh路径（Gavin是我的文件夹名，每个人不一样）下，找到id_rsa.pub公钥文件，用记事本打开，全文复制备用。

随后打开 Github，点击右上角头像 > Settings > SSH and GPG keys，点击 New SSH key，Title 随便填，Key type 默认，将刚才复制的公钥全文内容粘贴到 Key 一栏中，然后点击添加即可。

可以通过以下命令测试连接。

1
ssh -T git@github.com

返回 Hi Gavin-Meskin-Chen! 表示正常连接到了 Github。

Node安装

一定要注意，新电脑上的 node 版本要与旧电脑的 node 版本一致。

所以我们要先在旧电脑上运行node -v命令查看 node 版本号，然后从 Node历史版本页面 找到对应版本的 msi 安装包，比如我的版本是18.4.2，那我就下载 node-v18.14.2-x64.msi 文件。随后按提示安装即可，通过node -v和npm -v即可检查是否成功安装指定版本。

通过以下第一条命令可以设置国内阿里镜像源。我这里不需要阿里镜像源，可以用第二条命令删除它。

1
2
npm config set registry https://registry.npmmirror.com
npm config delete registry

Hexo安装

在博客文件夹下右键打开 git bash，输入以下命令即可安装 hexo。

1
2
npm install hexo-cli -g
npm install hexo-deployer-git --save

由于我的配置是使用 HTTPS 地址部署，所以执行hexo d时会弹出 GitHub 登录框，所以还需要进行额外 PAT 配置。

首先需要生成 PAT，登录 GitHub，点击右上角头像 > Settings > Developer settings > Personal access tokens > Tokens (classic)，点击 Generate new token，选择有效期 No expiration，可以勾选所有权限，生成后复制保存（注意它只会显示一次，一定要妥善保存）。

下次推送时，在弹出的登录框中，我们点击 Token，输入刚才的 token 即可。

最后，直接将旧电脑的博客文件夹复制到新电脑即可，里面包含了主题文件和所有需要的库，无需重新安装。

博客文件仓库

我的博客文件都放在了npm上，所以另外还需要一个仓库。新建 Programs 文件夹，右键打开 git bash，执行命令。

1
git clone git@github.com:Gavin-Meskin-Chen/BlogData.git

上传命令：

1
2
3
4
5
6
cd /d D:/Programs/BlogData

git add .
git commit -m "npm publish"
npm version patch
git push

Wallpaper

Wallpaper采用“枪弹分离”模式，下载到新电脑后，文件夹分类并不会一同同步过来，还是老老实实手动一个个重新分类。

参考下面Hope麻匪的B站视频。

是弊端 也是保命符 Wallpaper Engine 玩法规则介绍

https://www.bilibili.com/video/BV1TMiBYUEqs

From —— bilibili@Hope麻匪

引自外站地址，不确保可用性和安全性

其他软件的迁移都比较简单，到时候有新的槽点继续补充。

关于生态

以前用的华为生态，手机和电脑可以多屏协同，实现剪贴板共享、文件共享，十分方便。现在换成不同品牌的手机电脑，顿时感受到了巨大的落差。

首先就是文件传输问题，一下子又回到了高中时期之前那种用QQ微信传输文件的时代，我还得挨个儿管理不同设备上QQ微信的下载目录。其次是剪贴板共享，我被迫换掉了使用十几年的百度输入法（电脑端）和讯飞输入法（手机端），他们都是各领域的佼佼者，讯飞输入法的语音输入更是断档领先，但现在只能都换成支持剪贴板共享的微信输入法。至于浏览器，以前都是用的华为浏览器和chrome，多端同步书签很方便，现在只能用edge。

Edge和微信输入法其实都是很好的工具，他们的血液新鲜，设计美观，但最大的问题就是稳定性差。短短几天，这台新电脑上，edge已经卡死过好几次了，手机端的微信输入法也出现过两三次无法唤起的情况。以前我电脑端用chrome（包括华为浏览器）、百度输入法，手机端用华为浏览器、讯飞输入法，从来没有出现过哪怕一次程序崩溃的情况。

当然了，他们是后来者，或许需要技术沉淀，希望他们能更快进步吧。

]]> 我的新电脑迁移记录，包括QQ微信聊天记录迁移、博客迁移等 海星S5手电筒——高颜值性价比强光小直筒 https://blog.cancin.cn/post/82c75ff8.html 2025-01-20T02:13:49.000Z 2025-04-08T06:24:57.986Z 随便聊聊

我的第一支手电是2017年买的沃尔森mini，为了放学路上照明使用的，当时看它足够小巧，功能齐全，价格也便宜，就直接入手了。

沃尔森mini

沃尔森mini的灯芯采用的是CREE Q5，最高光通量为220流明。它使用14500电池进行供电，同时兼容普通5号电池，这一点是比较方便的。镜头方面支持阻尼调焦，可以伸缩调整光斑大小。沃尔森迷你全身筒长仅93mm，平时可以直接放在口袋里，这样的尺寸放在现在依然惊艳。可惜灯芯实在过于落后了，亮度极低。

最近在B站看了几个up主的手电测评视频，了解了一些手电方面的基本信息，很快入手了我的第二支手电——海星S5。

海星S5

手电厂商主要分品牌厂和DIY厂两类，品牌厂的价格普遍在几百以上，我预算有限，只能看DIY厂商。DIY厂商比较知名的有Convoy（俗称毛裤）、海星、农夫、匹欧曼等，很多人推荐入坑第一款是毛裤的S21E或者海星的Z2/Z2C，但我没有选择它们，因为它们都是侧边按钮的形式，不太习惯，而且外观也不太好看。

海星S5-三段筒身

选择海星S5的首要原因是它的颜值，虽然是公模，但直筒的设计确实好看。其次它的价格够低，在60左右（以下价格皆为裸机不带电池），相比之下毛裤S21E在100价位，海星Z2在80价位。另外海星S5使用18650电池，而毛裤S21E和海星Z2皆为21700电池，由于我家里有18650电池和相应的充电器，但没有21700电池和充电器，所以选择S5就免去了额外的充电套装费用，同时也带来了相对更小的尺寸。

海星S5

下面介绍一下这款海星S5，先看具体参数。

海星S5有丰富的配色，红橙黄绿蓝紫黑等等各种颜色都有，我买的是钛色版本。另外灯珠也有多种可选，常见的像朗明纳斯SST40W、日亚519AT、CREE XHP50.3等，可惜没有SFT40W版本的，我买的是SST40W灯珠，6500K色温。一般来说SST40属于远泛兼顾型，SFT40远射较强，519AT显色能力强。

海星S5的光杯默认是橘面，也可以跟客服说要光面的。橘面顾名思义就是光杯面像橘子皮一样麻麻赖赖的，而光面则光滑如镜，体现出来的实际效果是橘面泛光效果好，而光面中心光斑更亮更适合远射灯珠。镜片采用的是高透光的镀膜玻璃，可以减少对光通量的削弱。

海星S5的尺寸为118mm*24.1mm，不大不小，倒也一手可握，直筒造型使其拥有极佳的握持手感。供电方面使用18650型电芯，我用的是亿纬锂能35V，3500mAh容量，这款电芯内阻小，很多人推荐它。

海星S5由弱到强一共有4个档位，第1档月光档26mA，第2档低亮935mA，第3档中亮1900mA，第4档高亮5000mA，任意档下双击是爆闪模式。最高档有温控，只能坚持90s，120s降到第3档，一般开第3档也够了。低电量情况下灯会慢闪提示。

其他产品

由于海星S5是一款公模手电，所以你能看到其他厂商也有一样的款式，不过价格、驱动等方面有差距。像匹欧曼K11，要便宜几块钱，而且他家有SFT40版本，而毛裤家的S21A和S2+要贵的多，价格上到了90左右。相比于其他厂家同模的产品，海星S5有个比较喜欢的点是它的尾按是金属的，而其他家一般是硅胶的。

至于毛裤S21E和海星Z2C，有很多人推荐，它们在性能方面像续航、最高亮度等方面肯定是比海星S5更好，但尺寸也大一些，要根据自己需要取舍。另外毛裤S21E和海星Z2C（Z2不支持）自带Type-C充电接口，不需要取出电池充电（当然也支持取出电池充电），省去了另外购买电池充电器的费用，平时出行也不用带多余的充电器。

如果预算低于50以下，松美G40是唯一的神，性价比拉满。

品牌厂我看了两三个，那个奈特科尔（NITECORE）的EDC35还蛮喜欢，最高5000流明，124mm的长度也不算太大。还有个漫客E05-II，最高1300流明，91mm的长度，迷你且精致。

参考视频

B站有个叫流明实验室的up主，专门做品牌厂手电的测评，还有一个我见山青kk也做手电测评，他是品牌厂和DIY厂都做。

]]> <h2 id="随便聊聊"><a href="#随便聊聊" class="headerlink" 2025年记事 https://blog.cancin.cn/post/d5f63bc.html 2025-01-01T02:12:40.000Z 2026-03-18T12:39:23.931Z
]]> 没啥好看的 逝者如斯 https://blog.cancin.cn/post/d7050bec.html 2024-09-06T15:04:27.000Z 2025-02-01T03:38:46.000Z

大痴不迷，大喜不颠，大悲不泣，大悟不言。

篇一

没有什么路是白走的，没有什么事情是白做的，这些看似无意义的事情，都是成长的基石。在我们的生命中的每个插曲都有着自己该有的意义，所以不要抱怨为什么不早点儿做，更不要后悔要是做了什么就好了。你有后悔、抱怨的时间，不如整装待发前进起来。有时候只有走错了路，才逐渐明白自己要的未来；只有交错了朋友，才逐渐知道什么是患难见真情；只有爱错过人，才逐渐懂得真爱是什么。

篇二

一代人

黑夜给了我黑色的眼睛，我却用它寻找光明。

星月的来由

树枝想去撕裂天空，
却只戳了几个微小的窟窿，
它透出天外的光亮，
人们把它叫做月亮和星星。

我的幻想

我在幻想着，
幻想在破灭着；
幻想总把破灭宽恕，
破灭却从不把幻想放过。

感觉

天是灰色的，
路是灰色的，
楼是灰色的，
雨是灰色的，

在一片死灰中，
走过两个孩子，
一个鲜红，
一个淡绿。

失事

屋顶上又蒙了雪
雪上又有了煤
一千七百米上空
又开始闪烁

琴说
青春是一把琴
不要弹它
要抚摸它

一千七百米上空
突然断掉

远和近

你
一会看我
一会看云

我觉得
你看我时很远
你看云时很近

弧线

鸟儿在疾风中
迅速转向

少年去捡拾
一枚分币

葡萄藤因幻想
而延伸的触丝

海浪因退缩
而耸起的背脊

在淡淡的秋季

在淡淡的秋季
我多想穿过
枯死的篱墙，走向你
在那迷朦的湖边
悄悄低语
唱起儿歌
小心地把雨丝躲避

生活中只有感觉
生命中只有教义
当我们得到了生活
生命便悄悄飞离
像一群被打湿的小鸽子
在雾中
失去踪迹

不，不是这支歌曲
在小时候没有泪
只有露滴
每滴露水里
都有浅红色的梦
当我们把眼睛紧紧闭起

哦，在淡淡的秋季
我没有走向你
没有唱，没有低语
我沿着篱墙
向失色的世界走去
为明天的歌
能飘在晴空里

在陌生的街上

在陌生的街上
有许多人跳舞
跳的神秘而莫测
使我不能通过

由于长久的等待
我变成了路牌
指向希望的方向
没有一字说明

历史

我们的嘴唇第一次拥有
蓝色的水
盛满陶罐
还有十几只南方的星辰
火种
最初由上的别离
岁月呵

你是穿黑色衣服的人
在野地里发现第一枝植物
脚插进土地
再也拔不出
那些寂寞的花朵
是春天遗失的嘴唇
岁月呵 岁月

公元前我们太小
公元后我们又太老
没有谁见过
那一次真正美丽的微笑
但我还是举手敲门
带来的象形文字
洒落一地
岁月呵 岁月

到家了
我缓缓摘下帽子
靠着爱我的人
合上眼睛
一座古老的铜像坐在墙壁中间
青铜浸透了泪水
岁月呵

篇三

人间一趟，灿日碧洋。
一期一会，念念不忘。

于他可无为，于己须有为。

]]> <blockquote> <p>大痴不迷，大喜不颠，大悲不泣，大悟不言。</p> </blockquote> <h2 id="篇一"><a href="#篇一" class="headerlink" 从你的全世界路过 https://blog.cancin.cn/post/5d356fa3.html 2024-09-04T03:43:37.000Z 2025-01-07T12:40:32.000Z
]]> 有东西被加密了, 请输入密码查看。 简约风格音乐外挂标签 https://blog.cancin.cn/post/a3bac35.html 2024-06-29T05:32:30.000Z 2025-03-07T06:57:20.000Z 简述
  • 结构简单，功能简单，支持播放、暂停、播放进度控制。
  • 每个音频单独播放，互不影响，且与控制中心的 Aplayer 相互独立。
  • 如果喜欢该音频，可以点击右侧加号按钮添加至 Aplayer 歌单列表，实现全局播放，同时可使用 Aplayer 的桌面歌词功能。

格式

1
{% music 标题,作者,链接,封面,歌词 %}

【注】参数两端不可使用引号；各参数间以英文逗号为分割，故参数不可携带英文逗号。

预览

cover
贫道 刘心 --:-- / --:--

音源

我主要使用网易云的音乐资源，在音乐单曲界面按F12可获取封面链接，页面网址则包含了该歌曲的id，而音频链接格式如下：

1
`https://music.163.com/song/media/outer/url?id=${id}.mp3`

除此之外也可以通过 Meting API 获取相关资源。

实现

新建 themes\butterfly\scripts\tag\music.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
'use strict'
function music(args) {
    args = args.join(' ').split(',')
    let title = (args[0] || '未知').trim()
    let author = (args[1] || '未知').trim()
    let url = (args[2] || '').trim()
    let pic = (args[3] || '').trim()
    let lrc = (args[4] || '').trim()
    return `<center><figure id="mc-${title}" class="music-card">
        <div class="player">
            <audio class="audio" preload="metadata"></audio>
        </div>
        <div class="content">
            <div class="mc-progress" onclick="setProgress(event, 'mc-${title}')">
                <div class="mc-progressbar"></div>
            </div>
            <div class="cover">
                <img src="${pic}">
                <div class="play" onclick="ctrl.mcToggleMusic('mc-${title}', '${url}')">
                    <i class="blogfont icon-play-circle"></i>
                </div>
            </div>
            <div class="text-info">
                <span class="title">${title}</span>
                <span class="author">${author}</span>
                <span class="time">--:--&nbsp;/&nbsp;--:--</span>
            </div>
            <div class="add" onclick="ctrl.addMusicToList('${title}','${author}','${url}','${pic}','${lrc}')">
                <i class="blogfont icon-add"></i>
            </div>
        </div>
        <script>
            function mcAddListener(id) {
                const mc = document.getElementById(id)
                if (mc) {
                    const mc_audio = mc.querySelector('.audio')
                    const mc_play = mc.querySelector(".play i")
                    let intervalId;
                    mc_audio.addEventListener('play', function() {
                        mc_play.classList.remove("icon-play-circle")
                        mc_play.classList.add("icon-pause-circle")
                        intervalId = setInterval(function() {
                            ctrl.mcRefreshTime(id)
                        }, 500);
                    })
                    mc_audio.addEventListener('pause', function() {
                        mc_play.classList.remove("icon-pause-circle")
                        mc_play.classList.add("icon-play-circle")
                        clearInterval(intervalId)
                    })
                }
            }
            function setProgress(e, id) {
                const mc = document.getElementById(id)
                if (mc && mc.querySelector(".content").classList.contains("canplay")) {
                    const progressBar = mc.querySelector('.mc-progressbar')
                    const audio = mc.querySelector('.audio')
                    const clickX = e.clientX - mc.getBoundingClientRect().left
                    const width = clickX / mc.offsetWidth
                    progressBar.style.transform = 'translateX(-' + (1 - width) * 100 + '%)'
                    audio.currentTime = width * audio.duration
                    ctrl.mcRefreshTime(id)
                }
            }
            mcAddListener('mc-${title}')
        </script>
    </figure></center>`
}

hexo.extend.tag.register('music', music, { ends: false })

新建 themes\butterfly\source\css\/_tags\music.styl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
.music-card
    border-radius: 21px
    border: 1px solid var(--gavin-border-color)
    background-color: var(--gavin-widget-bg1)
    box-shadow: var(--gavin-shadow-1)
    height: 80px
    width: 100%
    max-width: 350px
    margin: 1em 0
    overflow: hidden

    .content
        position: relative
        display: flex
        align-items: center
        width: 100%
        height: 100%

        .mc-progress
            width: 100%
            height: 100%
            z-index: 10
            display: flex
            justify-content: left

            .mc-progressbar
                height: 100%
                width: 100%
                transform: translateX(-100%)
                background-color: var(--gavin-highlight-op-1)

        .cover
            position: absolute
            left: 10px
            top: 10px
            width: 60px
            height: 60px
            background-color: var(--gavin-secondbg)
            border: 1px solid var(--gavin-border-color)
            border-radius: 10px
            overflow: hidden
            z-index: 11

            .play
                position: absolute
                top: 0
                width: 100%
                height: 100%
                display: flex
                align-items: center
                justify-content: center
                cursor: pointer
                opacity: 0

                i
                    display: flex
                    align-items: center
                    justify-content: center
                    font-size: 35px
                    color: rgba(255,255,255,.8)

        &:hover
            .play
                opacity: 1

        &.canplay
            a
                img
                    filter: brightness(0.8) !important

            .play
                opacity: 1

        .text-info
            position: absolute
            left: 80px
            max-width: calc(100% - 150px)
            display: flex
            flex-direction: column
            text-align: left
            z-index: 9

            .title
                font-size: 16px
                line-height: 1.3
                display: -webkit-box
                overflow: hidden
                -webkit-box-orient: vertical
                -webkit-line-clamp: 1

            .author
                font-size: 13px
                line-height: 1.3
                opacity: .8
                display: -webkit-box
                overflow: hidden
                -webkit-box-orient: vertical
                -webkit-line-clamp: 1

            .time
                font-size: 10px
                line-height: 1.4
                display: -webkit-box
                overflow: hidden
                -webkit-box-orient: vertical
                -webkit-line-clamp: 1
                opacity: .6

        .add
            position: absolute
            right: 20px
            top: 20px
            width: 40px
            height: 40px
            border-radius: 50%
            background-color: var(--gavin-op-dis-05)
            display: flex
            align-items: center
            justify-content: center
            cursor: pointer
            z-index: 11

            &:hover
                background-color: var(--gavin-op-dis-1)

            i
                display: flex
                align-items: center
                justify-content: center
                font-size: 21px

自定义 custom.js 中加入以下代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
var ctrl = {
    clearConsoleMusicList() {
        document.getElementById("console-music-list").innerHTML = ''
    },

    addMusicToList(title, author, url, pic, lrc) {
        var ap = document.querySelector("meting-js.global-music").aplayer;
        ctrl.clearConsoleMusicList();
        // ap.list.clear();
        ap.list.add([{"title": title, "author": author, "url": url, "pic": pic, "lrc": lrc}]);
        ap.list.switch(ap.list.audios.length - 1)
    },

    mcToggleMusic(id, url) {
        const mc = document.getElementById(id)
        if (mc) {
            const c = mc.querySelector(".content")
            if (!c.classList.contains("canplay")) {
                const a = mc.querySelector(".audio")
                a.src = url
                a.addEventListener('loadeddata', function f() {
                    c.classList.add("canplay")
                    a.removeEventListener('loadeddata', f)
                });
            }
            const mc_audio = mc.querySelector(".audio")
            if (mc_audio.paused) {
                mc_audio.play()
            } else {
                mc_audio.pause()
            }
        }
    },

    mcRefreshTime(id) {
        var mc = document.getElementById(id)
        if (mc) {
            var mc_audio = mc.querySelector(".audio")
            var t0 = mc_audio.currentTime + 0.5
            var t1 = mc_audio.duration
            var _t0 = tools.secToTime(t0)
            var _t1 = tools.secToTime(t1)
            mc.querySelector(".time").innerHTML = `${_t0}&nbsp;/&nbsp;${_t1}`
            mc.querySelector(".mc-progressbar").style.transform = "translateX(-" + ((1 - (t0 / t1)) * 100) + "%)"
        }
    }
}

var tools = {
    secToTime(s) {
        if (isNaN(s)) s = 0;
        var min = Math.floor(s / 60);
        var sec = Math.floor(s % 60);
        var t = min.toString().padStart(2, '0') + ":" + sec.toString().padStart(2, '0');
        return t;
    }
}
]]> 自用音乐标签，支持单击进度调节 数字电子技术基础（7）——脉冲波形的产生和整形 https://blog.cancin.cn/post/bb918626.html 2024-01-07T01:48:20.000Z 2025-01-07T12:40:32.000Z 施密特触发器

施密特触发器具有2个稳态，主要应用有：波形变换、脉冲整形、鉴幅。

门电路构成的施密特触发器如图所示，电路中2个CMOS反相器串接，从$v_o$输出即为同相输出，从$v_o'$输出即为反相输出。

门电路构成的施密特触发器

同相（左）反相（右）逻辑符号

同相（左）反相（右）电压传输特性

假设COMS反相器的阈值电压，，则正向阈值电压为：

负向阈值电压为：

回差电压为：

施密特触发器的应用：

  1. 波形变换

    波形变换

  2. 脉冲整形

    脉冲整形

  3. 鉴幅

    鉴幅

单稳态触发器

单稳态触发器有1个稳态、1个暂稳态，主要应用有：脉冲整形、延时、定时。

门电路构成的微分型单稳态触发器

单稳态触发器的暂稳态持续时间（脉宽）与R、C有关：

多谐振荡器

多谐振荡器没有稳态。多谐振荡器在接通电源后无需外加触发信号，即可自动产生富含高次谐波的矩形脉冲（自激）。

施密特触发器构成多谐振荡器

555定时器

555定时器外接少量电阻电容可以构成施密特触发器、单稳态触发器、多谐振荡器。

555定时器电路结构

555定时器构成施密特触发器

555定时器构成施密特触发器

如果参考电压由外接$V_{CO}$提供：

如果没有外接$V_{CO}$：

555定时器构成单稳态触发器

555定时器构成单稳态触发器

工作波形

555定时器构成多谐振荡器

555定时器构成多谐振荡器

工作波形

C充电时：

C放电时：

振荡周期：

占空比：

]]> <h2 id="施密特触发器"><a href="#施密特触发器" class="headerlink" 数字电子技术基础（6）——门电路、存储器 https://blog.cancin.cn/post/f9e8bc9c.html 2024-01-07T01:03:10.000Z 2025-01-07T12:40:32.000Z MOS晶体管

MOS管是金属-氧化物-半导体场效应晶体管的简称，它有3个电极——源极S（Source）、栅极G（Gate）、漏极D（Drain），衬底一般与源极相连 。它是电压控制器件，以栅极电压控制漏极电流。

MOS管根据导电沟道的不同可以分为PMOS和NMOS，按形成沟道的工作方式不同可以分为增强型和耗尽型。故共有4种构型：增强型NMOS、增强型PMOS、耗尽型NMOS、耗尽型PMOS。数字电路中多采用增强型MOS管作为开关管。

增强型NOS、增强型PMOS、耗尽型NMOS、耗尽型PMOS

符号助记：增强型-三个短横；耗尽型-一个长横。N-箭头朝内；P-箭头朝外。

MOS管有3个工作区：截止区、恒流区（饱和区）、可变电阻区（非饱和区）。MOS管的开关时间，取决于负载电容的充放电时间。

增强型NMOS管输出特性曲线

CMOS逻辑门电路

CMOS反相器、CMOS传输门，是CMOS逻辑电路的2种基本模块。

  1. CMOS反相器

    CMOS反相器构成：增强型PMOS（负载管，上）、增强型NMOS（驱动管，下）串联。

    CMOS反相器

  2. CMOS与非门

    CMOS与非门是由2个并联的PMOS管和2个串联的NMOS管构成。

    CMOS与非门

  3. CMOS或非门

    CMOS或非门是由2个并联的NMOS管和2个串联的PMOS管构成。

    CMOS或非门

  4. CMOS传输门

    CMOS传输门由一个增强型PMOS和一个增强型NMOS并联互补组成。

    CMOS传输门

    传输门的信号可以双向传输。用CMOS传输门和CMOS反相器可以组成双向模拟开关，还可以构成各种复杂的逻辑模块，比如同或门等。

    CMOS双向模拟开关

    CMOS同或门

  5. OD门、OC门

    CMOS集成电路有3种输出结构：推挽输出、三态输出、漏极开路输出。

    普通推挽输出的CMOS门电路输出端不能并联使用。

    三态输出：高电平、低电平、高阻态。三态门可以实现数据双向传输，所以它可以实现总线结构。三态门的结构有2种，一种是低电平控制，一种是高电平控制。

    低电平控制CMOS三态门

    高电平控制CMOS三态门

    漏极开路输出可以实现线与，例如CMOS的OD门、TTL的OC门。其中TTL的OC门使用时必须外接负载电阻到VCC（1-2.5K）。

    开漏输出的与非门

双极型晶体管

  1. 二极管与门

    二极管与门

  2. 二极管或门

    二极管或门

  3. 三极管非门（反相器）

    三极管非门

CMOS、TTL总结

CMOS集成电路的优点是静态功耗很低，同时存在动态功耗，与工作频率成正比。

TTL速度高、抗干扰能力强，逻辑电平摆幅大。CMOS速度较TTL低，功耗低，抗干扰能力、带负载能力强，电源利用率高。

TTL与门：多余闲置端接1、和使用端并联、悬空；TTL或门：多余闲置端接0、和使用端并联；

CMOS：不能悬空！TTL悬空是接1。CMOS或非门接小电阻（510）到地，相当于接低电平0。

TTL与非门的灌电流负载发生在输出 低电平(0) 情况下，拉电流负载发生在输出 高电平(1) 情况下。

存储器的分类

按制造工艺可以分为双极型和MOS型存储器。双极型速度快，功耗大，价格高，工艺复杂；MOS型速度相对慢一点，但功耗低，集成度高，成本低。

按照应用角度分为随机存储器（RAM）和只读存储器（ROM）。RAM是可读可写存储器，但断电后数据会丢失。RAM又分静态存储器（SRAM）和动态存储器（DRAM），DRAM结构简单、集成度高、速度慢，SRAM相反。ROM只能读取不能写入，断电后信息不会丢失。

除此之外还有多种存储器：

  • 掩模ROM，不可修改；
  • PROM，可修改1次；
  • EPROM，可通过光擦写（紫外线）多次修改（耗时长）；
  • E²PROM，可通过电擦写多次修改。

存储器的应用

固定ROM的基本结构如图所示，其中A为n条地址输入线，W为$2^n$条字线，D为m条位线，存储容量就是$2^n×m$bit。

固定ROM的基本结构

ROM的地址译码器是与逻辑阵列，位线和字线的逻辑关系是或逻辑关系，所以使用ROM可以实现逻辑函数：

ROM实现逻辑函数

存储器的扩展

  1. 位扩展

    1K×1扩展为1K×4

  2. 字扩展

    8K×8扩展为32K×8

  3. 位和字扩展

    1K×4扩展为2K×8

]]> <h2 id="MOS晶体管"><a href="#MOS晶体管" class="headerlink" 数字电子技术基础（5）——时序逻辑电路 https://blog.cancin.cn/post/93e8f639.html 2024-01-06T11:51:07.000Z 2025-01-07T12:40:32.000Z 概念

  1. 特点

    时序电路任意时刻的输出信号不仅取决于当时的输入信号，还与初始状态及以前的输入有关。时序电路通常包括组合电路和存储电路两部分，另外包含输出到输入的反馈回路。

  2. 分类

    时序电路根据时钟不同，可以分为同步时序电路和异步时序电路，根据输出信号的特点，可以分为米利型（Meely）和摩尔型（Moore）。

    • 米利型：F(X,Q)，输出信号取决于状态和输入；
    • 摩尔型：F(Q)，输出信号仅取决于状态。

  3. 表示方法

    逻辑方程（驱动方程、状态转移方程、输出方程）、状态转移表、状态转移图、时序图等。

一般时序逻辑电路的分析与设计

同步与异步

同步和异步的概念是指电路的变化与时钟脉冲是否同步。

时序逻辑电路的分析

同步时序逻辑电路的分析步骤如下：

  1. 列出各级触发器的驱动方程；
  2. 将驱动方程代入触发器特性方程，得到转移方程；
  3. 列出输出方程；
  4. 由输出方程和状态转移方程，列出状态转移表，画出状态转移图和波形图；
  5. 总结概括电路的逻辑功能。

异步时序逻辑电路的分析需要注意各级触发器的CP时钟源。

自启动

若偏离态能在脉冲信号作用下自动转入到有效序列，则电路可以自启动，否则不能自启动。

时序逻辑电路的设计

同步时序逻辑电路的设计步骤如下：

  1. 根据实际需要建立状态转移图和状态转移表；
  2. 原始状态化简；
  3. 状态编码；
  4. 选择触发器类型；
  5. 检查电路自启动，绘制电路图。

异步时序逻辑电路的设计需要注意触发器时钟信号的选择，选取原则：

  1. 触发器状态需要翻转的时候，必须要有时钟信号输入；
  2. 触发器状态不需要翻转的时候，多余的时钟信号越少越好。

常用时序逻辑电路

计数器

计数器有多种实用功能，如计数、分频、定时、产生节拍脉冲、脉冲序列和数字运算等，故又称分频器。最大计数称为计数器的模，符号N。

计数器的分类：

  • 根据脉冲方式分为：同步计数器、异步计数器；
  • 根据逻辑功能分为：加法计数器、减法计数器、可逆计数器；
  • 根据模值划分。

生活中常用集成计数器，主要有可逆计数、预置、清零、进位等功能。

常见集成计数器

74LS161

74LS161是4位同步二进制计数器，模为16。为同步预置数控制端，为异步清零端，CO为进位输出端。EP和ET为工作状态控制端，当EP为0，ET为任意态，CO保持；当ET为0，EP为任意态，CO为0。

逻辑符号图

功能表

计数器的扩展

设需要设计的模值为M，已有计数器模值为N。

当N>M时，可利用同步预置取M个状态（N-M到N-1），或者利用异步清零，取M+1（0到M，其中M是瞬间出现而后消失）。需要注意的是，对于异步清零法的设计，为了提高清零信号的可靠性，通常需要在清零信号前加一个基本RS触发器，如下所示：

改进电路

在改进后的电路中，由基本RS触发器的R'端接计数器的清零端，R端作为进位输出端。

置数法实现模8计数的2种思路

当N<M时，需要多片计数器级联。在设计任意模值计数器前，不妨试着分析已有的计数器级联电路。

清零法构成29进制计数器

由图可知，当片1输出为1001（9）且片2输出为0010（2）时，2片计数器同时异步清零，74LS160为模10计数，故整体电路模值为10×2+(9-1+1)=29。加1是因为0到n，计数n+1次；减1是因为异步清零，末态瞬间消失，所以这里最好也加上一个基本RS触发器，或者改用置数法实现。如下图所示（10×2+(8+1)=29）。

置数法法构成29进制计数器

寄存器和移位寄存器

寄存器分为基本寄存器和移位寄存器，基本寄存器只能并入并出，移位寄存器可以在移位脉冲作用下依次逐位右移或左移，数据可以并入并出、并入串出、串入串出、串入并出。

串入并出

串入串出

模4环形计数器

模8扭环形计数器

并入串出

并入并出

一般来说，规定左为低位、右为高位，即，此时左移右移直观可见。

74LS194

74LS194是一款常见的集成式4位双向移位寄存器。

74LS194逻辑符号图

74LS194功能表

2片74LS194级联实现8位移位寄存器

74LS195

74LS195具有JK输入，只能进行右移操作，端补位值遵循。

74LS195逻辑符号图

74LS195功能表

一般n位移位寄存器可以实现模值n的环形计数器及模值2n的扭环形计数器。

序列信号发生器

一般分为移存型序列信号发生器和计数型序列信号发生器。

移存型序列信号发生器

移存型序列信号发生器一般由移位寄存器和组合反馈电路构成，设计方法：

  1. 首先根据序列信号长度，确定最少触发器数目n，对于计数型序列信号发生器，须满足：
  2. 通过分组，验证n是否满足需要（若分组中有重复的，则需要验证n+1个触发器）
  3. 按编码编写状态转移表，状态转移表最后一列即为反馈信号D
  4. 求反馈函数D并化简
  5. 检查电路自启动，画出逻辑图。

计数型序列信号发生器

计数型序列信号发生器的输出位于组合输出电路，另外不用验证自启动，其最大的优点是可以同时产生多个序列。

例如下图，可以产生10101、11011两种序列：

image-20240106194940608

]]> <h2 id="概念"><a href="#概念" class="headerlink" 2024年记事 https://blog.cancin.cn/post/e29d0882.html 2024-01-06T01:55:13.000Z 2025-07-21T02:23:45.445Z
]]> 没啥好看的