凯特网

人民币大写在线转换工具

Fri, 30 Jan 2026 17:09:50 +0800

人民币大写在线转换工具

在线将阿拉伯数字转换成中文大写、人民币大写转换工具

人民币大写转换器

输入小写数字金额：

显示中文大写金额：

已成功复制到剪贴板！

大写对照表

数字转大写

数字	大写

金额单位

单位	大写

人民币符号：¥

美元符号：$

欧元符号：€

英镑符号：￡

转换示例

转换规则说明：

中文大写金额数字前应标明"人民币"字样，大写金额数字应紧接"人民币"字样填写，不得留有空白。

阿拉伯数字小写金额数字中有"0"时，中文大写应按照汉语语言规律、金额数字构成和防止涂改的要求进行书写。

中文大写金额数字到"元"为止的，在"元"之后、应写"整"(或"正")字；在"角"之后，可以不写"整"(或"正")字；大写金额数字有"分"的，"分"后面不写"整"(或"正")字。

具体示例：

输入：¥206000.75

输出：人民币贰拾万陆仟元零柒角伍分，或人民币贰拾万零陆仟元柒角伍分

输入：¥1001.00

输出：人民币壹仟零壹元整

输入：¥0.56

输出：人民币伍角陆分

输入：¥888.80

输出：人民币捌佰捌拾捌元捌角

使用说明

在"输入小写数字金额"框中输入或粘贴阿拉伯数字金额（例如：123456.78）
点击"转换为大写金额"按钮，转换结果将显示在"显示中文大写金额"框中
点击"复制大写金额"按钮，将转换结果复制到剪贴板
上方对照表提供了数字与大写的对应关系，方便查阅
转换示例展示了不同金额的转换规则和结果
如需清空输入框，可直接删除内容并重新输入

MODBUS-RTU CRC16 在线计算器

Wed, 10 Dec 2025 12:16:52 +0800

CRC16计算器 - 多组数据

可输入多组16进制数串（用英文逗号分隔每组），实时计算每组数据的CRC16值。使用查表法计算，输出结果包含带0x前缀的输入数据和CRC16值（低字节在前）。

输入多组16进制数串（用英文逗号分隔每组，组内用空格分隔数字）:

请输入多组16进制数字，每组用英文逗号分隔，组内用空格分隔数字。无需添加0x前缀，支持大写和小写字母。

输出结果 (共0组):

等待输入...

测试提示: 使用"01 02 03 04 05"测试，正确CRC16应为: 0xBB2A (低字节: 0x2A, 高字节: 0xBB)

示例:

输入: 01 02 03 04 05, 0A 0B 0C, FF 00 AA BB CC

输出:

第1组: 0x01 0x02 0x03 0x04 0x05 0x2A 0xBB

第2组: 0x0A 0x0B 0x0C 0x4A 0x7B

第3组: 0xFF 0x00 0xAA 0xBB 0xCC 0x04 0xBC

总结，如何查阅valgrind内存泄漏检测报告

Fri, 11 Jul 2025 11:53:42 +0800

检测命令

valgrind --tool=memcheck --leak-check=full --log-file=valgring.log ./hriExecCtrl

报告结论

==417113== LEAK SUMMARY:
==417113==    definitely lost: 14,528 bytes in 96 blocks
==417113==    indirectly lost: 1,302,289 bytes in 273 blocks
==417113==      possibly lost: 16,400 bytes in 41 blocks
==417113==    still reachable: 6,568,169 bytes in 13,367 blocks
==417113==                       of which reachable via heuristic:
==417113==                         stdstring          : 31,621 bytes in 839 blocks
==417113==                         newarray           : 1,104 bytes in 4 blocks
==417113==         suppressed: 0 bytes in 0 blocks
==417113== Reachable blocks (those to which a pointer was found) are not shown.
==417113== To see them, rerun with: --leak-check=full --show-leak-kinds=all
==417113== 
==417113== Use --track-origins=yes to see where uninitialised values come from
==417113== For lists of detected and suppressed errors, rerun with: -s
==417113== ERROR SUMMARY: 4871 errors from 197 contexts (suppressed: 0 from 0)

报告解析

1. 泄漏分类总结
Valgrind 将内存泄漏分为 4 类（按严重性排序）：
(1) Definitely Lost（明确泄漏）14,528 bytes in 96 blocks
	最严重的泄漏：程序直接丢失了动态分配的内存（如 malloc/new 但未释放）。
	可能原因：忘记调用 free()/delete，或指针丢失后无法释放。
	修复建议：检查 96 处分配点的代码，确保每次分配都有对应的释放。
(2) Indirectly Lost（间接泄漏）1,302,289 bytes in 273 blocks
	关联结构体/类的内存泄漏：例如，某个结构体指针泄漏导致其内部成员指针也无法释放。
	可能原因：复杂数据结构（如链表、树）的根节点泄漏，或析构函数未正确释放成员。
	修复建议：检查数据结构的生命周期管理，确保根节点释放时能递归释放所有成员。
(3) Possibly Lost（可能泄漏）16,400 bytes in 41 blocks
	潜在指针错误：分配的内存指针可能被错误计算（如 ptr+1 导致 free(ptr) 无法匹配）。
	可能原因：指针运算错误或数组越界。
	修复建议：检查这 41 处指针的使用逻辑，确保 free() 的参数与 malloc() 完全一致。
(4) Still Reachable（仍可访问）6,568,169 bytes in 13,367 blocks
	非泄漏但未释放的内存：程序退出时这些内存仍被全局/静态指针引用（如全局变量、单例模式）。
	常见情况：
	程序未主动释放全局资源（如缓存、配置对象）。
	C++ 的 std::string 或容器（如 std::vector）在全局对象中持有内存。
	是否需要修复？
	如果这些内存是故意保留的（如程序重启时复用），可以忽略。
	如果是临时缓存，应在程序退出前手动释放。
	细分提示：
	stdstring: 31,621 bytes in 839 blocks：大量字符串未释放。
	newarray: 1,104 bytes in 4 blocks：动态数组未释放。
2. 其他关键信息
	ERROR SUMMARY: 4871 errors from 197 contexts
	程序存在 4871 处内存错误（如非法读写、使用未初始化值等），需结合完整日志分析。
	使用 --track-origins=yes 定位未初始化值的来源。
	Reachable blocks are not shown	默认不显示“仍可访问”的内存详情。

openEuler 24.03 docker 存储路径修改实操

Wed, 02 Apr 2025 09:46:50 +0800

确认原始存储路径

安装完docker后，它的默认存储路径是

/var/lib/docker

如果不确定，可以通过指令

docker info

也可以直接通过指令查看

docker info | grep "Docker Root Dir"

确认好后，记录好。

停止docker服务

systemctl stop docker.service

创建新的存储路径

mkdir -p /home2/docker
chown -R root:root /home2/docker

迁移同步原来存储路径的资料到新的存储路径

rsync -avz /var/lib/docker/ /home2/docker

修改docker服务配置文件

vim /etc/systemd/system/multi-user.target.wants/docker.service

找到以下位置

[Service]
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

修改成以下内容

[Service]
ExecStart=ExecStart=/usr/bin/dockerd --data-root=/home2/docker

重新启动docker服务

systemctl daemon-reload
systemctl start docker

查看docker服务状态

systemctl status docker

NTC热敏电阻在线计算器

Tue, 25 Mar 2025 22:52:39 +0800

NTC热敏电阻计算器

B值：

25℃标称电阻(Ω)：

起始温度(℃)：

结束温度(℃)：

步进值(℃)：

以下输出电阻值的顺序对应的是起始温度到结束温度，单位为欧姆，步进大小与上面设置相关。

U盘安装openEuler 24.03 LTS SP1实操记

Mon, 10 Mar 2025 17:10:24 +0800

网上虽然有安装指南，但是个人认为非常不接地气，可能是有特殊原因吧。我这里来一个接地气的，综合总结了前人的经验。重点介绍如何改造U盘内容以适应安装，确保一次成功。

不改造U盘内容的话会出现卡住的情况，提示：“Insaller errors encountered during boot:....”

1.下载工具，UltraISO

（请自行网上搜索下载）

2.下载系统镜像文件

https://www.openeuler.org/zh/download/#openEuler%2024.03%20LTS%20SP1

3.制作刷机U盘

3.1.启动 UltraISO

3.2.加载下载好的镜像文件

3.3.写入硬盘映像

4.修改U盘中的启动文件

4.1.打开“我的电脑”查看U盘标签，这里是“openEuler-2”记录好，后面要用

4.2.打开U盘进入目录“H:\EFI\BOOT”

编辑文件“grub.cfg”

5.准备刷机，U盘插到目标机的USU口上

5.1.进入主机BIOS设置为UEFI模式（如果主板不支持传统模式就不用改了）

5.2.重启选择从U盘启动--微星主板按F11/F12(要么是F11要么是F12，我是交替按，直到看到以下画面)

5.3.进入启动选项，选择第二项

等待一会......

接下来就是愉快的安装过程了哈。

Linux Shell脚本实现INI文件添加、删除、修改及读取操作

Thu, 06 Mar 2025 11:39:27 +0800

感谢DeepSeek大模型，生成的脚本，稍作修改即可使用。先上使用说明，后附完整代码。

#!/bin/bash

VERSION="1.0"
SCRIPT_NAME=$(basename "$0")

show_help() {
    cat << EOF
Usage: $SCRIPT_NAME <command> [options]

Commands:
  add      Add a new key-value pair to a section
  update   Update an existing key-value pair
  delete   Delete a key or entire section
  read     Read a value from the INI file

Options:
  -f, --file    INI file path (required)
  -s, --section Section name (required for all commands)
  -k, --key     Key name (required for add/update/delete/read)
  -v, --value   Value to set (required for add/update)

Examples:
  $SCRIPT_NAME add -f config.ini -s Database -k host -v localhost
  $SCRIPT_NAME read -f config.ini -s Database -k host
EOF
}

add_ini() {
    local file="$1"
    local section="$2"
    local key="$3"
    local value="$4"

    # Create file if not exists
    [ -f "$file" ] || touch "$file"

    # Check if key already exists
    if grep -q "^\[$section\]" "$file"; then
        if awk -v section="$section" -v key="$key" '
            BEGIN { in_section = 0 }
            /^\[.*\]$/ { in_section = ($0 == "[" section "]") }
            in_section && $1 == key { found = 1; exit }
            END { exit !found }' FS='=' "$file"; then
            echo "Error: Key '$key' already exists in section [$section]" >&2
            return 1
        fi
    fi

    # Add new entry
    if ! grep -q "^\[$section\]" "$file"; then
        # Section doesn't exist, append to end
        printf "\n[%s]\n%s=%s\n" "$section" "$key" "$value" >> "$file"
    else
        # Section exists, insert after section header
        sed -i.bak -e "/^\[$section\]/a $key=$value" "$file"
    fi
}

update_ini() {
    local file="$1"
    local section="$2"
    local key="$3"
    local value="$4"

    # Verify section exists
    if ! grep -q "^\[$section\]" "$file"; then
        echo "Error: Section [$section] does not exist" >&2
        return 1
    fi

    # Verify key exists
    if ! awk -v section="$section" -v key="$key" '
        BEGIN { in_section = 0 }
        /^\[.*\]$/ { in_section = ($0 == "[" section "]") }
        in_section && $1 == key { found = 1; exit }
        END { exit !found }' FS='=' "$file"; then
        echo "Error: Key '$key' not found in section [$section]" >&2
        return 1
    fi

    # Update value
    sed -i.bak -e "/^\[$section\]/,/^\[/s/^$key\s*=.*/$key=$value/" "$file"
}

delete_ini() {
    local file="$1"
    local section="$2"
    local key="$3"

    if [ -z "$key" ]; then
        # Delete entire section
        sed -i.bak -e "/^\[$section\]/,/^\[.*\]/ { /^\[$section\]/d; /^\[.*\]/!d; }" "$file"
    else
        # Delete specific key
        sed -i.bak -e "/^\[$section\]/,/^\[/ { /^$key\s*=/d }" "$file"
    fi
}

read_ini() {
    local file="$1"
    local section="$2"
    local key="$3"
	local found=0
    awk -v section="$section" -v key="$key" '
        BEGIN { FS = "="; in_section = 0 }
        /^\[.*\]$/ {
            in_section = ($0 == "[" section "]")
        }
        in_section && $1 == key {
            print $2
			found = 1
            exit
        }
        END {
            if (!found) {
                if (!in_section) {
                    print "Error: Section [$section] not found" > "/dev/stderr"
                } else {
                    print "Error: Key '$key' not found" > "/dev/stderr"
                }
                exit 1
            }
        }
    ' "$file"
}

# Main command processing
case $1 in
    add|update|delete|read)
        cmd=$1
        shift
        ;;
    -h|--help)
        show_help
        exit 0
        ;;
    -v|--version)
        echo "$SCRIPT_NAME version $VERSION"
        exit 0
        ;;
    *)
        echo "Error: Unknown command '$1'" >&2
        show_help
        exit 1
        ;;
esac

# Parse common options
file=""
section=""
key=""
value=""

while [[ $# -gt 0 ]]; do
    case $1 in
        -f|--file)
            file="$2"
            shift 2
            ;;
        -s|--section)
            section="$2"
            shift 2
            ;;
        -k|--key)
            key="$2"
            shift 2
            ;;
        -v|--value)
            value="$2"
            shift 2
            ;;
        --)
            shift
            break
            ;;
        -*)
            echo "Error: Invalid option '$1'" >&2
            exit 1
            ;;
        *)
            break
            ;;
    esac
done

# Validate required parameters
[ -z "$file" ] && { echo "Error: Missing --file parameter" >&2; exit 1; }
[ -z "$section" ] && { echo "Error: Missing --section parameter" >&2; exit 1; }

case $cmd in
    add|update)
        [ -z "$key" ] && { echo "Error: Missing --key parameter" >&2; exit 1; }
        [ -z "$value" ] && { echo "Error: Missing --value parameter" >&2; exit 1; }
        ;;
    delete|read)
        [ -z "$key" ] && key=""
        ;;
esac

# Execute command
case $cmd in
    add)
        add_ini "$file" "$section" "$key" "$value"
        ;;
    update)
        update_ini "$file" "$section" "$key" "$value"
        ;;
    delete)
        delete_ini "$file" "$section" "$key"
        ;;
    read)
        read_ini "$file" "$section" "$key"
        ;;
esac

DeepSeek 的 Coder、Chat 和 Reasoner 模型的区别

Tue, 04 Mar 2025 16:20:34 +0800

以下内容引自DeepSeek问答，仅供参考

1. DeepSeek-Coder

定位：代码生成与理解
特点：

支持 300+ 编程语言，擅长生成代码片段、补全代码、修复错误、代码注释等。
长上下文支持：最高支持 16K Token 上下文，适合处理复杂代码工程。
评测表现：在 HumanEval、MBPP 等代码评测中超越同规模模型（如 CodeLlama）。
规模选择：提供 1.3B、5.7B、6.7B、33B 多种参数版本，适配不同算力需求。

适用场景：

开发者辅助编程工具
代码库分析与自动化
编程教育（如代码纠错教学）

2. DeepSeek-Chat

定位：通用对话与交互
特点：

多轮对话优化：擅长理解上下文、生成自然流畅的回复。
多语言支持：中英文表现均衡，兼顾知识问答、文本创作、逻辑推理等综合能力。
安全对齐：通过 RLHF 等技术减少有害输出，符合实际应用需求。
模型规模：通常基于 7B/67B 参数版本，支持 4K~32K Token 上下文。

适用场景：

智能客服、虚拟助手
内容创作（如文案生成）
日常问答与信息检索

3. DeepSeek-Reasoner

定位：数学与逻辑推理
特点：

推理过程优化：通过强化学习（RL）和过程监督（Process Supervision）提升分步推理能力。
数学能力突出：在 MATH、GSM8K 等数学评测中达到 SOTA（尤其是 7B 小模型）。
可解释性：生成详细解题步骤，便于验证逻辑正确性。
训练数据：融合数学问题、定理证明、符号推理等专项数据。

适用场景：

数学题目求解与辅导
复杂逻辑问题分析
学术研究中的符号推理任务

对比总结

维度	Coder	Chat	Reasoner
核心能力	代码生成与理解	通用对话交互	数学与逻辑推理
关键数据	代码仓库、编程文档	多轮对话语料、百科知识	数学问题、定理证明
技术亮点	长上下文代码建模	安全对齐与多轮交互优化	过程监督强化推理
典型应用	IDE 插件、代码自动化	客服、内容生成	教育、科研分析

选择建议

需要编程辅助 ➔ 选 Coder
需要通用对话或多任务处理 ➔ 选 Chat
需解决数学问题或复杂逻辑 ➔ 选 Reasoner

可通过 DeepSeek 的官方仓库（GitHub）和 Hugging Face 获取模型细节与试用。

STM32F405 SPI模式读写SD卡挂载失败的一种原因

Tue, 24 Dec 2024 21:00:46 +0800

最近研究通过SPI的模式读写SD卡，调试时发现，在调用 f_mount 挂载SD卡时，程序就会卡死，进入到 HardFault_Handler 死循环中。单步时发现是在f_mount 函数中调 find_volume 时跑飞的。

由于第一次使用SD卡，也没有什么调试经验，在网上刨了一下，最终让我找到了情况与我类似的。https://shequ.stmicroelectronics.cn/thread-620714-1-1.html

于是照着改了代码，确实成功了，在此分享。

上面圈出来的两个值，开始时被设置成了相同的值都是512，把_MAX_SS改成4096试了下就成功了。

引用FFTW3读取并估计wav文件音频的基频

Mon, 23 Dec 2024 15:25:04 +0800

接上一篇《不引用第三方库读取wav文件并逐帧估算基频》，这里引用了第三方专用库FFTW3，实现同样的功能。

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <fftw3.h>

#pragma comment( lib, "libfftw3-3.lib")
#pragma comment( lib, "libfftw3f-3.lib")
#pragma comment( lib, "libfftw3l-3.lib")

// WAV文件头结构
typedef struct {
    char riff[4];
    uint32_t overall_size;
    char wave[4];
    char fmt_chunk_marker[4];
    uint32_t length_of_fmt;
    uint16_t format_type;
    uint16_t channels;
    uint32_t sample_rate;
    uint32_t byte_rate;
    uint16_t block_align;
    uint16_t bits_per_sample;
    char data_chunk_header[4];
    uint32_t data_size;
} WAV_HEADER;

// 读取WAV文件头
WAV_HEADER read_wav_header(FILE* file) {
    WAV_HEADER header;
    fread(&header, sizeof(WAV_HEADER), 1, file);
    return header;
}

// 读取WAV文件的音频数据
float* read_wav_data(FILE* file, WAV_HEADER header, int* num_samples) {
    int data_size = header.data_size / (header.bits_per_sample / 8);
    float* data = (float*)malloc(data_size * sizeof(float));
    short int* temp = (short int*)malloc(header.data_size);

    fread(temp, sizeof(short int), header.data_size / sizeof(short int), file);

    for (int i = 0; i < data_size; i++) {
        data[i] = (float)temp[i] / 32768.0; // 假设是16位PCM编码，范围是-32768到32767
    }

    free(temp);
    *num_samples = data_size;
    return data;
}

// 估算基频（简单峰值检测）
double estimate_fundamental_frequency(fftw_complex* out, int N, double sample_rate) {
    double max_magnitude = 0.0;
    int max_index = 0;

    // 查找FFT结果中的最大峰值（除了直流分量）
    for (int i = 1; i < N / 2; i++) {
        double magnitude = sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]);
        if (magnitude > max_magnitude) {
            max_magnitude = magnitude;
            max_index = i;
        }
    }

    // 计算基频
    double fundamental_frequency = (double)max_index * (sample_rate / N);
    return fundamental_frequency;
}
// 自定义基频估算函数（简单峰值检测）
double custom_estimate_fundamental_frequency(fftw_complex* out, int N, double sample_rate) {
    double max_magnitude = 0.0;
    int max_index = 0;
    int start_index = N / (sample_rate / 10.0); // 假设我们只对10Hz到采样率一半之间的频率感兴趣
    int end_index = N / 2; // FFT结果的对称性，只考虑前半部分

    // 查找FFT结果中的最大峰值（在指定范围内）
    for (int i = start_index; i < end_index; i++) {
        double magnitude = sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]);
        if (magnitude > max_magnitude) {
            max_magnitude = magnitude;
            max_index = i;
        }
    }

    // 如果找到了峰值，则计算对应的频率
    if (max_index > 0 && max_index < end_index) {
        double fundamental_frequency = (double)max_index * (sample_rate / N);
        return fundamental_frequency;
    }
    else {
        // 如果没有找到明显的峰值，则返回0或某个表示未找到基频的值
        return -1.0; // 这里返回-1表示未找到基频，实际应用中可以根据需要调整
    }
}
// 自定义基频估算函数（简单峰值检测）
double estimate_fundamental_frequency(double* magnitudes, int N, double sample_rate) {
    double max_magnitude = 0.0;
    int max_index = 0;
    int start_index = N / (sample_rate / 10.0);     // 假设我们只对10Hz到采样率一半之间的频率感兴趣
    int end_index = N / 2;                          // FFT结果的对称性，只考虑前半部分

    // 查找FFT结果中的最大峰值（在指定范围内）
    for (int i = start_index; i < end_index; i++) {
        if (magnitudes[i] > max_magnitude) {
            max_magnitude = magnitudes[i];
            max_index = i;
        }
    }

    // 如果找到了峰值，则计算对应的频率
    if (max_index > 0 && max_index < end_index) {
        double fundamental_frequency = (double)max_index * (sample_rate / N);
        return fundamental_frequency;
    }
    else {
        // 如果没有找到明显的峰值，则返回0或某个表示未找到基频的值
        return -1.0; // 这里返回-1表示未找到基频，实际应用中可以根据需要调整
    }
}
int main(int argc, char* argv[]) {
    //if (argc != 2) {
    //    fprintf(stderr, "Usage: %s <wav_file>\n", argv[0]);
    //    return 1;
    //}

    FILE* file = fopen("wdsyy1.wav", "rb");
    if (!file) {
        perror("Failed to open file");
        return 1;
    }

    WAV_HEADER header = read_wav_header(file);

    // 检查是否是PCM编码的WAV文件
    if (header.format_type != 1) {
        fprintf(stderr, "Unsupported WAV format\n");
        fclose(file);
        return 1;
    }

    int num_samples;
    float* data = read_wav_data(file, header, &num_samples);
    fclose(file);

    // 设置FFT大小（通常是2的幂）
    int N = 1024; // 可以根据需要调整
    while (N < num_samples) N *= 2;

    // 为FFT准备输入和输出数组
    fftw_complex* in = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * N);
    fftw_complex* out = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * N);
    //fftw_plan plan = fftw_plan_dft_r2c_1d(N, (double*)data, out, FFTW_ESTIMATE);
    //fftw_plan plan = fftw_plan_dft_1d(N, in, out, FFTW_ESTIMATE);
    // 将音频数据填充到FFT输入数组中（注意：只填充前num_samples个值，其余置零）
    for (int i = 0; i < num_samples; i++) {
        in[i][0] = data[i];
        in[i][1] = 0.0;
    }
    for (int i = num_samples; i < N; i++) {
        in[i][0] = 0.0;
        in[i][1] = 0.0;
    }
    fftw_plan plan = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
    // 执行FFT
    fftw_execute(plan);

    // 计算FFT结果的幅度
    double* magnitudes = (double*)malloc(sizeof(double) * (N / 2 + 1));
    for (int i = 0; i <= N / 2; i++) {
        magnitudes[i] = sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]);
    }

    // 估算基频
    //double fundamental_frequency = estimate_fundamental_frequency(out, N, header.sample_rate);
    //double fundamental_frequency = custom_estimate_fundamental_frequency(out, N, header.sample_rate);

    // 估算基频
    double fundamental_frequency = estimate_fundamental_frequency(magnitudes, N, header.sample_rate);

    printf("Estimated fundamental frequency: %.2f Hz\n", fundamental_frequency);

    // 清理
    fftw_destroy_plan(plan);
    fftw_free(in);
    fftw_free(out);
    free(data);

    return 0;
}

运行结果

FFTW3库文件（头文件，lib,dll）

fftw-3.3.5_x86.rar

X64由于文件超大了，所以分开了，下载后放到一起即可。

fftw-3.3.5_x64_1.rar

fftw-3.3.5_x64_2_1.rar

fftw-3.3.5_x64_2_3.rar

fftw-3.3.5_x64_2_2.rar