Blogs on 星沉地动的个人博客

Windows 10(11)让人诟病的问题强行阉割控制面板

Tue, 15 Jul 2025 14:21:11 +0000

Windows 10(11)最大的问题不是 UI设计的严重分裂，而是微软强行阉割控制面板的功能，却没有在“设置”应用中提供完整的替代方案 ，导致用户被迫在两个残缺的界面之间来回切换，体验极其糟糕。

单独使用“控制面板”或者使用“系统设置”都不能完整实现特定功能。

1. 控制面板被删减的功能（典型例子）

微软并没有完整迁移控制面板的所有功能到“设置”应用，而是 选择性保留 ，导致很多高级设置只能在旧版控制面板中找到，甚至有些功能被直接删除。例如：

(1) 网络和共享中心

控制面板 提供完整的 高级共享设置 （如网络发现、文件和打印机共享、密码保护共享）。
设置应用 仅提供基础的网络状态和 Wi-Fi 管理， 无法直接配置高级共享选项 。

(2) 电源管理

控制面板 允许调整 CPU 最大/最小状态 （影响性能和省电）。
设置应用 仅提供简单的“电源模式”（最佳性能/平衡/省电）， 无法精细调节 。

(3) 设备和打印机

控制面板 可以管理 蓝牙设备、打印机队列、扫描仪属性 。
设置应用 仅提供基础的设备列表， 无法管理打印任务或调整设备高级属性 。

(4) 文件关联

控制面板 允许 批量修改文件关联 （如 .txt 默认用 Notepad++ 打开）。
设置应用 只能逐个文件类型修改， 效率极低 。

(5) 用户账户管理

控制面板 可以 直接修改本地用户组策略 （如管理员权限）。
设置应用 仅提供基础的账户管理， 无法直接修改高级权限 。

2. 微软为何这样做？

(1) 强制推动 UWP（通用 Windows 平台）

微软希望淘汰 Win32 旧代码，推广现代化的 UWP 应用，但 迁移不彻底 ，导致功能缺失。

Makefile参考样例5：多个文件夹.c和.cpp混合编译

Wed, 18 Jun 2025 16:35:26 +0000

样例4只能编译纯C文件，现在添加C++的支持。

同时添加环境变量CROSS_COMPILE支持灵活跨平台编译。

源代码根目录为src，所有源码在src的子目录会被编译。

#CROSS_COMPILE ?= 

CC      = $(CROSS_COMPILE)gcc
CXX     = $(CROSS_COMPILE)g++
LD      = $(CROSS_COMPILE)g++
STRIP   = $(CROSS_COMPILE)strip

#编译选项
DEFINES  = -DTEST=1
CFLAGS   = -O0 -Wall -Wformat-overflow=0 $(DEFINES)
CXXFLAGS = -O0 -Wall -Wformat-overflow=0 $(DEFINES)
LDFLAGS  = -Wl,-gc-sections -Wl,-rpath=lib -Wl,-rpath='$$ORIGIN' -lpthread -lm

#目录结构
target   = main
srcdir   = src
objdir   = build
srcsub   = $(shell find $(srcdir) -type d)
objsub   = $(patsubst $(srcdir)/%,$(objdir)/%,$(srcsub))

#源文件查找
csrc    = $(foreach dir,$(srcsub),$(wildcard $(dir)/*.c))
cxxsrc  = $(foreach dir,$(srcsub),$(wildcard $(dir)/*.cpp))
obj     = $(patsubst $(srcdir)/%.c,$(objdir)/%.o,$(csrc)) $(patsubst $(srcdir)/%.cpp,$(objdir)/%.o,$(cxxsrc))
dep     = $(patsubst $(srcdir)/%.c,$(objdir)/%.d,$(csrc)) $(patsubst $(srcdir)/%.cpp,$(objdir)/%.d,$(cxxsrc))

#包含路径
CFLAGS   += $(foreach dir,$(srcsub),-I$(dir))
CXXFLAGS += $(foreach dir,$(srcsub),-I$(dir))
LDFLAGS  += $(foreach dir,$(srcsub),-L$(dir))

#依赖生成规则
$(objdir)/%.d: $(srcdir)/%.c
	@echo "Generating $@..."
	@$(CC) -MM -MT "$(@:.d=.o) $@" $(CFLAGS) $< > $@

$(objdir)/%.d: $(srcdir)/%.cpp
	@echo "Generating $@..."
	@$(CXX) -MM -MT "$(@:.d=.o) $@" $(CXXFLAGS) $< > $@

#编译规则
$(objdir)/%.o: $(srcdir)/%.c
	@echo "Compiling $<..."
	@$(CC) $(CFLAGS) -c $< -o $@

$(objdir)/%.o: $(srcdir)/%.cpp
	@echo "Compiling $<..."
	@$(CXX) $(CXXFLAGS) -c $< -o $@

ifeq ($(MAKELEVEL), 1)
include $(dep)
endif

.PHONY: all clean

all: $(objsub) $(dep)
	@$(MAKE) -s $(target)

clean:
	@echo Clean target...
	@rm -rf $(target) $(objdir)
	@echo Clean done!

$(objsub):
	@mkdir -p $@

$(target): $(obj)
	@echo Linking...
	@$(LD) $(LDFLAGS) -o $@ $^
	@$(STRIP) $@
	@echo Build done!

RTX系列桌面显卡历史驱动版本

Tue, 22 Apr 2025 11:06:25 +0000

收集目前RTX系列桌面显卡的历史驱动版本，方便查询和遇到问题需要回退版本等情况。

操作系统：Windows 10/11 64位驱动类型：Studio稳定版

发布日期	版本	大小	最新系列	下载地址
2025年4月16日	V576.02	857.02MB	RTX50系列	https://www.nvidia.com/zh-cn/drivers/details/244316/
2025年3月18日	V572.83	845.25MB	RTX50系列	https://www.nvidia.cn/Download/driverResults.aspx/242211/cn
2025年2月27日	V572.60	844.73MB	RTX50系列	https://www.nvidia.cn/Download/driverResults.aspx/241096/cn
2025年1月30日	V572.16	844.61MB	RTX50系列	https://www.nvidia.cn/Download/driverResults.aspx/240532/cn
2024年12月10日	V566.36	732.88MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/237789/cn
2024年11月12日	V566.14	722.9MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/235974/cn
2024年10月15日	V565.90	711.63MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/232938/cn
2024年9月17日	V561.09	691.04MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/232608/cn
2024年8月6日	V560.81	701.16MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/230790/cn
2024年7月16日	V560.70	729.31MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/230099/cn
2024年6月4日	V555.99	659.34MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/227413/cn
2024年5月21日	V555.85	659.29MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/224940/cn
2024年4月16日	V552.22	665.46MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/224288/cn
2024年3月19日	V551.86	665.42MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/223566/cn
2024年2月22日	V551.61	665.33MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/221749/cn
2024年1月24日	V551.23	665.15MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/218480/cn
2023年12月12日	V546.33	701.86MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/216964/cn
2023年11月1日	V546.01	701.66MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/216402/cn
2023年10月10日	V537.58	675.86MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/212835/cn
2023年9月21日	V537.42	675.85MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/211721/cn
2023年8月8日	V536.99	675.81MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/210528/cn
2023年7月18日	V536.67	676.07MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/209305/cn
2023年6月29日	V536.40	685.29MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/209199/cn
2023年5月30日	V535.98	685.28MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/205174/cn
2023年4月13日	V531.61	895.67MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/204249/cn
2023年3月21日	V531.41	894.11MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/200287/cn
2023年2月8日	V528.49	854.49MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/199794/cn
2023年1月23日	V528.24	852.95MB	RTX40系列	https://www.nvidia.cn/Download/driverResults.aspx/198734/cn
2023年1月5日	V528.02	851.54MB	RTX40系列	http://www.nvidia.cn/Download/driverResults.aspx/198430/cn
2022年12月8日	V527.56	852.95MB	RTX40系列	http://www.nvidia.cn/Download/driverResults.aspx/197400/cn
2022年11月16日	V526.98	852.84MB	RTX40系列	http://www.nvidia.cn/Download/driverResults.aspx/194422/cn
2022年10月18日	V522.30	841.94MB	RTX40系列	http://www.nvidia.cn/Download/driverResults.aspx/193888/cn
2022年9月20日	V517.40	825.34MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/193239/cn
2022年8月9日	V516.94	822.22MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/193019/cn
2022年7月26日	V516.93	823.96MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/191058/cn
2022年6月29日	V516.59	822.56MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/190620/cn
2022年5月23日	V512.96	824.9MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/189621/cn
2022年4月26日	V512.59	823.22MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/187646/cn
2022年3月22日	V512.15	824.96MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/187308/cn
2022年2月1日	V511.65	821.14MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/186818/cn
2022年1月4日	V511.09	837.05MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/184789/cn
2021年12月13日	V472.84	758.46MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/184344/cn
2021年11月10日	V472.47	754.42MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/183662/cn
2021年10月26日	V472.39	757.23MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/183391/cn
2021年9月20日	V472.12	758.01MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/180818/cn
2021年8月10日	V471.68	756.11MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/179838/cn
2021年7月19日	V471.41	753.66MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/177926/cn
2021年6月23日	V471.11	754.97MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/176860/cn
2021年5月11日	V462.59	663.27MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/175409/cn
2021年4月14日	V462.31	662.84MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/172714/cn
2021年3月17日	V461.92	661.82MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/171734/cn
2021年2月25日	V461.72	659.69MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/171038/cn
2021年1月26日	V461.40	663.94MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/170528/cn
2020年12月15日	V460.89	658.44MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/168018/cn
2020年11月17日	V457.30	647.87MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/166997/cn
2020年10月20日	V456.71	640.61MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/166091/cn
2020年9月17日	V456.38	638.55MB	RTX30系列	http://www.nvidia.cn/Download/driverResults.aspx/163845/cn
2020年8月18日	V452.06	589.26MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/163288/cn
2020年7月16日	V451.77	589.33MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/162530/cn
2020年6月24日	V451.48	588.97MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/161491/cn
2020年4月16日	V442.92	555.99MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/159723/cn
2020年2月3日	V442.19	555.12MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/156950/cn
2019年12月10日	V441.66	554.01MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/155814/cn
2019年11月18日	V441.28	551.89MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/154474/cn
2019年11月4日	V441.12	554.47MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/153393/cn
2019年9月4日	V431.86	520.87MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/151097/cn
2019年7月29日	V431.70	521.12MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/149185/cn
2019年5月27日	V430.86	518.57MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/148013/cn
2019年3月20日	V419.67	579.15MB	RTX20系列	http://www.nvidia.cn/Download/driverResults.aspx/145445/cn

SSH: PTY allocation request failed on channel 0

Tue, 04 Mar 2025 16:44:43 +0000

SSH登陆成功后，出现如下错误：

PTY allocation request failed on channel 0

问题原因：

没有挂载/dev/pts

解决方法：

mount -t devpts devpts /dev/pts

或者

mount -t devpts -o gid=5,mode=620 devpts /dev/pts

Windows远程协助实现跨网络连接的“黑科技”

Mon, 09 Dec 2024 17:59:59 +0000

为了和远方的朋友进行远程联机，我们组建了一个联机的VN网络，实现虚拟局域网。有一次使用Windows远程协助的时候，忘记连接VN，竟然成功连接上了！我和我的小伙伴都惊呆了！

环境是这样的：操作系统都是Windows 10(22H2) 电脑是通过中国电信的光猫联网。中国电信光猫没有公网IPv4，但有公网IPv6。但光猫默认配置是禁止所有的IPv6进站连接的。

所以排除2台电脑通过IPv6直联的情况。

继续研究发现远程协助的进程msra.exe监听的端口是随机的，但可以看到监听了一个IPv6地址。 2台电脑连接时，可以互相看到msra.exer是通过IPv6的地址连接的。

这个IPv6地址是哪来的呢？本机的网卡并没有这个IP地址。

经过一番研究，找到了，原来Windows创建了一个Teredo虚拟网卡：

继续研究这个虚拟网卡，找到了关键信息：这是IPv6的隧道技术。

结论：msra.exe启动的时候会尝试建立IPv6的隧道，来实现2台电脑的连接。这样一来，Windows远程协助的实用性得到极大的提升。在一般的应用场景下，基本可以告别“向日葵”，TeamViewer等第3方软件了。

通过分析，不使用msra，我们也可以手动创建隧道网络：

命令如下：

netsh interface teredo set state type=natawareclient servername=win1910.ipv6.microsoft.com. servervirtualip=0.0.0.0

执行这个命令后：查看ipconfig /all就能找到隧道IPv6的地址了。

这个命令重启后一般会失效，还可以到组策略开启这个功能：

组策略/计算机配置/管理模板/网络/TCPIP设置/IPv6转换技术/ 设置Teredo刷新率：30 设置Teredo服务器名称：win1910.ipv6.microsoft.com 设置Teredo状态：企业客户端

设置好后，重启电脑。

这样的IPv6地址可以实现Windows远程协助和 Windows远程桌面连接。

使用第3方软件暂时没有成功。

使用MSYS搭建linux开发环境踩坑笔记

Fri, 06 Dec 2024 09:00:10 +0000

前言：

使用linux系统或虚拟机进行嵌入式linux开发是常规方法；使用MSYS是用于尝鲜和研究。

由于windows和linux的差异，使用MSYS代替Linux虚拟机会遇到很多坑。主要原因在于：

windows和linux文件系统的差异：win不区分文件名大小写, linux要区分
路径分隔符的差异: win使用""分隔路径， linux使用"/“分隔路径
可执行文件的差异：win执行文件后缀名*.exe，linux可执行文件不需要后缀名

成果：

目前MSYS环境已经成功用于编译linux应用层软件，linux内核, U-Boot等。

踩坑1：传递编译参数-Wl,–dynamic-linker=/lib/ld-linux.so，编译后结果路径是错的！原因：MSYS调用mingw的gcc.exe传递路径参数时，会转换为windows文件路径。解决：MSYS工具链不要和mingw混用；路径使用双斜杠//开头也能凑合使用。

踩坑2：编译设备树失败： No rule to make target ‘arch/arm/boot/dts/*.dtb’, needed by ‘__build’. 原因：Makefile生成dtb需要调用dtc，而windows下面dtc编译出来是dtc.exe，文件名不一致。解决：把dtc.exe改名为dtc

踩坑3：创建软链接行为异常，导致一些编译脚本报错原因：ln -s创建软链接其行为竟然是复制文件/文件夹. 解决：添加环境变量:export MSYS=“winsymlinks:lnk”

持续更新…

CMake典型应用参考样例

Wed, 12 Jun 2024 13:35:09 +0000

CMake 是一个跨平台的自动化建构系统，用于管理软件构建过程。很久很久以前编译一个C/C++工程通常采用手写Makefile文件的方法。现在使用CMake则改为手写CMakeLists.txt文件，然后用CMake自动生成Makefile文件。由于手写CMakeLists.txt比手写Makefile要简便许多，因此CMake逐渐流行起来。

典型应用场景 工程目录结构如下：

├─build/
├─src/
├─CMakeLists.txt
└─mk.sh

build目录是一个空目录，用于存放编译生成的临时文件。 src目录是源代码目录，下面有若干子目录。 CMakeLists.txt文件则在根目录，管理整个工程。 mk.sh是快速编译脚本，省去频繁地敲cmake和make指令，也可以根据需要添加更多便捷功能。

mk.sh中的关键指令：

cd ./build
cmake ../
make -j4

下面是一个典型的CMakeLists.txt示例，以此为基础稍作修改就能应用到实际项目中。这个示例中，使用aux_source_directory来搜索指定目录下的所有源文件，并参与编译。同时也可以使用list(REMOVE_ITEM)来屏蔽指定的源文件不参与编译。

# 最小版本要求
cmake_minimum_required(VERSION 3.0)

# 指定目标系统
set(CMAKE_SYSTEM_NAME Linux)

# 指定目标平台
set(CMAKE_SYSTEM_PROCESSOR arm)

# 指定交叉编译工具链的根目录
set(TOOLCHAIN_PATH "/root/toolchain/gcc")

# 指定C编译器
set(CMAKE_C_COMPILER "${TOOLCHAIN_PATH}/bin/arm-linux-gnu-gcc")

# 指定C++编译器
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_PATH}/bin/arm-linux-gnu-g++")

# 指定C选项
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_FLAGS "-static -Wall")
set(CMAKE_C_FLAGS_RELEASE "-O2")
set(CMAKE_C_FLAGS_DEBUG "-g -rdynamic -O0")

# 指定C++选项
set(CMAKE_CXX_STANDARD 99)
set(CMAKE_CXX_FLAGS "-static -Wall")
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
set(CMAKE_CXX_FLAGS_DEBUG "-g -rdynamic -O0")

# 工程定义
project(main C CXX)

# 预定义
add_definitions(-DVERSION="1.0")

# 头文件包含路径
include_directories(
	./src
	./src/dir1
	./src/dir2
	./src/dir3
)

# 源文件
aux_source_directory(./src             SRC_LIST)
aux_source_directory(./src/dir1        SRC_LIST)
aux_source_directory(./src/dir2        SRC_LIST)
aux_source_directory(./src/dir3        SRC_LIST)

# 屏蔽特定源文件不参与编译
list(REMOVE_ITEM SRC_LIST "./src/dir2/file.c")

# 库文件路径
link_directories(build)

# 库文件
link_libraries(pthread)
link_libraries(m)

# 目标文件
add_executable(${PROJECT_NAME} ${SRC_LIST})

VS2017离线安装记录

Thu, 25 Apr 2024 10:59:55 +0000

制作离线安装包的方法：

1.找一台能上网的电脑，下载在线原版安装器: vs_community.exe

微软不提供下载了，我上传1份到CSDN：点我进入下载

2.在命令行输入命令：(注意不能换行，我这里换行是为了好看)

vs_community.exe 
--layout C:\vs2017 
--lang zh-CN 
--add Microsoft.VisualStudio.Workload.NativeDesktop
--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64
--add Microsoft.VisualStudio.Component.VC.ATLMFC
--add Microsoft.VisualStudio.Component.Windows10SDK.10240
# --add Microsoft.VisualStudio.Component.Windows10SDK.17763(默认SDK版本)
# --add Microsoft.VisualStudio.Component.VC.140(旧版本工具集，支持WinXP)

我这里只添加VC++所必需的组件，根据个人需求选择要下载的组件。组件的名字可以在下面链接找到： Visual Studio Community workload and component IDs | Microsoft Learn

3.等待下载完成, 将C:\vs2017文件夹打包，这就是离线安装包了。

离线安装

将刚才的压缩包解压。运行命令：

vs_community.exe --noweb

弹出安装界面，选择组件的时候注意不要选择刚才没下载的组件，否则会安装失败。

我下载好的离线包：链接: https://pan.baidu.com/s/1bkLRX0vyMuJKt-hPnEpsUg 提取码: mb4r

STM32F407移植OpenHarmony笔记9

Sun, 04 Feb 2024 16:40:13 +0000

继上一篇笔记，已经完成liteos内核的基本功能适配。今天尝试启动OHOS和XTS兼容性测试。

如何启动OHOS？ OHOS系统初始化接口是OHOS_SystemInit(void)，在内核初始化完成后，就能调用。

extern void OHOS_SystemInit(void);
OHOS_SystemInit();

OHOS_SystemInit函数在//base/startup/bootstrap_lite/services/source/system_init.c里面。它负责初始化系统组件，由于系统组件的初始化用了特殊的宏定义，比如：

CORE_INIT()
SYS_RUN()
SYS_SERVICE_INIT_PRI()
......

这些宏在ohos_init.h里面可以看到，利用编译器把这个函数放到指定的代码段，相当于在编译阶段生成一个静态数组，然后OHOS_SystemInit会从这个数组取出函数，再依次执行。要实现这样的机制还需要修改链接脚本，好消息是talkweb的demo代码已经帮我们写好了，直接拿来就能用。 LD脚本添加的内容长下面的样子：


    __zinitcall_bsp_start = .;
    KEEP (*(.zinitcall.bsp0.init))
    KEEP (*(.zinitcall.bsp1.init))
    KEEP (*(.zinitcall.bsp2.init))
    KEEP (*(.zinitcall.bsp3.init))
    KEEP (*(.zinitcall.bsp4.init))
    __zinitcall_bsp_end = .;
    ......
    __zinitcall_exit_start = .;
    KEEP (*(.zinitcall.exit0.init))
    KEEP (*(.zinitcall.exit1.init))
    KEEP (*(.zinitcall.exit2.init))
    KEEP (*(.zinitcall.exit3.init))
    KEEP (*(.zinitcall.exit4.init))
    __zinitcall_exit_end = .;

OHOS系统组件是按子系统来分类管理的，每个子系统下面又有多个组件，需要用哪些系统功能就要添加对应的组件到config.json文件里面去。每个组件都有一个专门的描述文件：bundle.json，描述组件的名字和适用系统类型等信息。

功能组件之间也存在依赖关系，目前我还不知道怎么查询依赖关系，只能凭经验手动添加来测试。在编辑config.json添加组件时，还有一个features字段，也不知道从哪找。

XTS是一个独立子系统，依赖组件不太清楚，只能根据编译报错信息往里面加，加到编译不报错为止。不过这就遇到一个奇怪的报错：

[OHOS ERROR] FAILED: gen/base/startup/init/services/param/liteos/lite_ohos_param_to_param_cfg_to_code.log 
[OHOS ERROR] /home/openharmony/prebuilts/python/linux-x86/3.9.2/bin/python3 ../../../base/startup/init/scripts/param_cfg_to_code.py --source /home/openharmony/base/startup/init/services/etc_lite/param/ohos_const/ohos.para --source /utils/sys_param/vendor.para --source /home/openharmony/base/startup/init/services/etc/param/ohos.para --dest_dir /home/openharmony/out/demo_board/hello/gen/init/

通过对比talkweb的demo，原来需要手写一个vendor.para文件，而且还要指定路径。需要在config.json里面添加产品适配器的路径，就是下面这行代码：

  "product_adapter_dir": "//vendor/demo/hello/hals",

这表示某些需要产品级适配的组件，会在这个目录去寻找对应的文件。刚才的报错就是“syspara_lite”这个组件所需要的适配文件。参考talkweb的demo，在这个目录下创建以下文件：

STM32F407移植OpenHarmony笔记8

Fri, 02 Feb 2024 18:15:40 +0000

继上一篇笔记，成功开启了littlefs文件系统，能读写FLASH上的文件了。今天继续研究网络功能，让控制台的ping命令能工作。

轻量级系统使用的是liteos_m内核+lwip协议栈实现网络功能，需要进行配置开启lwip支持。

lwip的移植分为两部分，一部分是sys_arch用于适配rtos，这部分liteos_m已经实现了，相关代码在：/kernel/liteos_m/components/net/lwip-2.1/porting/src

另一部分则是网卡驱动的适配，这部分代码适配起来和其它平台基本一样。自己写一个ethernetif.c，在里面实现ethernetif_init，完成网卡初始化。并定义一个struct netif实例，指定一些参数（如下），具体代码可以抄官方demo。

netif->name[0] = 'e';
netif->name[1] = 'n';
netif->output = etharp_output;
netif->linkoutput = low_level_output;

网卡驱动的大概流程：

ethernetif_init 由lwip在添加网卡的时候调用，初始化底层ETH模块；然后创建一个线程和信号量，用于接收ETH的数据；在接收线程里等待信号量，在ETH中断里发送信号量，唤醒接收线程；接收线程调用low_level_input读取ETH数据放入pbuf中，并返回这个pbuf; 最后将pbuf丢给netif->input处理，这个函数在/third_party/lwip/src/netif/ethernet.c里面。当协议栈要发送数据时，它会调用low_level_output，数据放在pbuf参数里面。

    struct pbuf *p;
    struct netif *netif = (struct netif *)&stm32_netif;
    for (;;)
    {
        if (osSemaphoreAcquire(ethSemaphore, osWaitForever) == osOK)
        {
            do {
                p = low_level_input(netif);
                if (p != NULL)
                {
                    if (netif->input(p, netif) != ERR_OK)
                    {
                        pbuf_free(p);
                    }
                }
            } while (p != NULL);
        }
    }

这里简单记录一下lwip的初始化过程：

STM32F407移植OpenHarmony笔记7

Thu, 01 Feb 2024 17:40:12 +0000

继上一篇笔记，成功启动了liteos_m内核，可以创建线程了，也能看到shell控制台了。今天研究文件系统，让控制台相关文件命令如mkdir和ls能工作。

liteos_m内核支持fatfs和littlefs两个文件系统， fatfs适用于SD卡， littlefs适用于NORFLASH，如W25Qxx系列。我的板子上刚好有W25Q64，试试接入littlefs文件系统。基于之前的研究经验，进入make menuconfig看看文件系统相关选项，先把它选上：

当启用文件系统后，LOS_KernelInit会调用OsVfsInit进行初始化， OsVfsInit又会调用LfsInit初始化littlefs，并把littlefs注册到vfs的类型列表。

那我们怎么使用它呢，怎么让littlefs读写我们的SPIFLASH呢？

经过调查，我们需要使用mount函数，进行挂载操作来绑定文件系统和FLASH设备。那就在bsp目录新建littlefs.c，参考代码：

#include <stdio.h>
#include "spiflash.h"
#include "lfs.h"
#include "los_fs.h"

static int LittlefsRead(int partition, UINT32 *offset, void *buf, UINT32 size)
{
    spiflash_read(*offset, buf, size);
    return LFS_ERR_OK;
}

static int LittlefsProg(int partition, UINT32 *offset, const void *buf, UINT32 size)
{
    spiflash_write(*offset, buf, size);
    return LFS_ERR_OK;
}

static int LittlefsErase(int partition, UINT32 offset, UINT32 size)
{
    spiflash_erase(offset, size);
    return LFS_ERR_OK;
}

static void LittlefsPartiton(void)
{
    int lens[1]={1024*1024};
    int addr[1]={0};
    LOS_DiskPartition("flash0", "littlefs", lens, addr, 1);
}

static void LittlefsMount(void)
{
    int ret;
    struct PartitionCfg lfs_cfg;
    lfs_cfg.readFunc = LittlefsRead;
    lfs_cfg.writeFunc = LittlefsProg;
    lfs_cfg.eraseFunc = LittlefsErase;
    lfs_cfg.readSize = 64;
    lfs_cfg.writeSize = 256;
    lfs_cfg.blockSize = 4096;
    lfs_cfg.blockCount = 256;
    lfs_cfg.cacheSize = 4096;
    lfs_cfg.partNo = 0;
    lfs_cfg.lookaheadSize = 64;
    lfs_cfg.blockCycles = 100;
    ret = mount(NULL, "/flash", "littlefs", 0, &lfs_cfg);
    printf("LittlefsInit ret=%d\n", ret);
}

int LittlefsInit(void)
{
    printf("LittlefsInit enter\n");
    spiflash_init();
    printf("SPIFLASH flash id=0x%x\n", spiflash_read_id());
    LittlefsPartiton();
    LittlefsMount();
    return LFS_ERR_OK;
}

LittlefsInit 函数是初始化文件系统函数，在main里面完成LOS_KernelInit之后再调用。 spiflash_init是我们实现的W25QXX的驱动，W25QXX使用的是STM32F407的SPI接口。

STM32F407移植OpenHarmony笔记6

Wed, 31 Jan 2024 17:40:16 +0000

继上一篇笔记，编译好STM32的裸机程序，能点亮LED灯了。下一步就是启动liteos_m内核了。

不过为了更好的调试代码，需要先把printf重定向到串口，基于gcc的printf重定向和Keil不一样。直接新建printf.c，在里面重写printf函数即可。

int printf(char const *fmt, ...)
{
    char buf[256];
    va_list ap;
    va_start(ap, fmt);
    int len = vsnprintf_s(buf, sizeof(buf), sizeof(buf) - 1, fmt, ap);
    UartWrite(buf, len);
    va_end(ap);
    return len;
}

UartWrite是写串口的函数，基于HAL库写串口驱动我就不介绍了。记得在printf之前要初始化UART和相关的GPIO。这里有2个细节需要注意： 1.写串口没有临界区保护，多线程printf会有竞争风险，等kernel跑起来了，到时候加上mutex。 2.格式化字符串的buf长度256，是在stack上开辟的，注意调用线程的stack空间要给够。

liteos_m内核已经完成了ARM cortex-m4的适配，理论上所有基于cortex-m4的MCU都能快速使用。我们只需要在main函数调用LOS_KernelInit()和LOS_Start()可以了。启动之前自己创建一个线程，用来闪灯。

static void LED_Blink(void)
{
	GPIO_InitTypeDef GPIO_InitStruct = {0};
	__HAL_RCC_GPIOA_CLK_ENABLE();
	GPIO_InitStruct.Pin = GPIO_PIN_4;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_PULLUP;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	GPIO_InitStruct.Alternate = 0;
	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    printf("enter led blink.\n");
	while(1)
	{
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
		LOS_TaskDelay(250);
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
		LOS_TaskDelay(250);
	}
}

static void InitTask(void)
{
    UINT32 taskID = 0;
    TSK_INIT_PARAM_S stTask = {0};
    stTask.pfnTaskEntry = (TSK_ENTRY_FUNC)LED_Blink;
    stTask.uwStackSize = 1024;
    stTask.pcName = "led";
    stTask.usTaskPrio = 1;
    LOS_TaskCreate(&taskID, &stTask);
    printf("task id=%d\n", taskID);
}

int main(void)
{
	HAL_Init();
	SystemClock_Config();
	UartInit();
	printf("init...\n");
	LOS_KernelInit();
	InitTask();
	LOS_Start();
    printf("BUG!!!\n");
	while(1);
}

运气好的话，编译下去，可以看到串口打印，同时LED也会闪烁。

STM32F407移植OpenHarmony笔记5

Wed, 31 Jan 2024 15:50:27 +0000

继上一篇笔记，搭建好STM32的编译框架，编译出来的OHOS_Image.bin并不能跑不起来。今天要在bsp里面添加一些代码，让程序能跑起来。

先从裸机点亮LED灯开始，准备以下3个文件:startup和system文件可以用OHOS官方代码。

/device/board/demo/demo_board/liteos_m/bsp/src/main.c
/device/board/demo/demo_board/liteos_m/bsp/src/system_stm32f4xx.c
/device/board/demo/demo_board/liteos_m/bsp/src/startup_stm32f407xx.s

main.c里面做最简单的初始化，由于官方soc提供的st库是HAL库，因此用HAL库点亮LED。

#include "stm32f4xx_hal.h"

void HAL_MspInit(void)
{
	__HAL_RCC_SYSCFG_CLK_ENABLE();
	__HAL_RCC_PWR_CLK_ENABLE();
}

void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

    __HAL_RCC_PWR_CLK_ENABLE();
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
 
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 25;
    RCC_OscInitStruct.PLL.PLLN = 336;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 7;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);

    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
    HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
}

//我的板子上有个LED，连接在PA4
static void LED_Blink(void)
{
	GPIO_InitTypeDef GPIO_InitStruct = {0};
	__HAL_RCC_GPIOA_CLK_ENABLE();
	GPIO_InitStruct.Pin = GPIO_PIN_4;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	GPIO_InitStruct.Pull = GPIO_PULLUP;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	GPIO_InitStruct.Alternate = 0;
	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	while(1)
	{
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);
		HAL_Delay(500);
		HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);
		HAL_Delay(500);
	}
}

int main(void)
{
	HAL_Init();
	SystemClock_Config();
	LED_Blink();
}

这段代码初始化LED引脚，然后500ms改变1次LED状态。这里面用到HAL_Delay函数，是由Systick中断驱动的延时函数，也考验中断能不能正常运行。

STM32F407移植OpenHarmony笔记4

Tue, 30 Jan 2024 17:27:35 +0000

上一篇写到make menuconfig报错，继续开整。

make menuconfig需要/device/soc/*下面有对应的Kconfig文件。直接去gitee下载stm32的配置文件拿来参考用。先提取Kconfig文件，后面再添加其它文件。https://gitee.com/openharmony/device_soc_st/tree/OpenHarmony-v3.2-Beta5/

soc下的目录结构如下：

└── soc
    └── st
        ├── Kconfig.liteos_m.defconfig
        ├── Kconfig.liteos_m.series
        ├── Kconfig.liteos_m.soc
        └── stm32f4xx
            ├── Kconfig.liteos_m.defconfig.series
            ├── Kconfig.liteos_m.defconfig.stm32f4xx
            ├── Kconfig.liteos_m.series
            └── Kconfig.liteos_m.soc

Kconfig.liteos_m.soc会在菜单里添加st这个SOC_COMPANY 还会扫描子目录下的Kconfig.liteos_m.soc，在stm32f4xx子目录下面的这个文件又向菜单添加SOC_STM32F407

Kconfig.liteos_m.series扫描子目录下的同名文件，在stm32f4xx子目录里的这个文件又向菜单添加SOC_SERIES_STM32F4xx

再次测试make menuconfig还是会报错：

warning: <choice> (defined at arch/arm/Kconfig:34) defined with type unknown

根据错误提示并找不到问题在哪，最后发现Makefile需要/vendor/demo/hello/kernel_configs/debug.config文件，空文件就行。

进入Platform选择 Soc和stm32f407。

Compat菜单下，选择newlibc

配置完菜单后，配置保存在.config，并生成config.h文件，同时还会向/vendor/demo/hello/kernel_configs/debug.config写入一部分配置内容。

再次编译看看报什么错：

[OHOS INFO] ERROR at //kernel/liteos_m/BUILD.gn:140:18: Unable to load "/home/openharmony/device/board/demo/BUILD.gn".

根据错误，添加BUILD.gn

# /device/board/demo/BUILD.gn
# https://kerndev.blog.csdn.net/

import("//kernel/liteos_m/liteos.gni")
module_name = get_path_info(rebase_path("."), "name")
module_group(module_name) {
    modules = [ "demo_board" ]
}

再次测试，继续根据错误提示，添加以下文件：

STM32F407移植OpenHarmony笔记3

Tue, 30 Jan 2024 16:03:27 +0000

接上一篇，搭建完环境，找个DEMO能跑，现在我准备尝试从0开始搬砖。

首先把/device和/vendor之前的代码全删除，这个时候用hb set命令看不到任何项目了。

/device目录是硬件设备目录，包括soc芯片厂商和board板级支持代码。创建目录规则：“device/{芯片厂商}/{芯片开发板}”。

/vendor目录是产品项目定义目录。创建目录规则：“vendor/{产品模组厂商}/{产品模组名称}”。

参考文档： zh-cn/device-dev/porting/porting-minichip-prepare.md · OpenHarmony/docs - Gitee.com

hb set是扫描/vendor/目录下的config.json，所以我们从这个文件开始。然后根据报错信息一步一步添加代码。

先依葫芦画飘，写一个最小配置文件，把它放到/vendor/demo/hello目录。

{
  "product_name": "hello",
  "ohos_version": "OpenHarmony 3.2",
  "type": "mini",
  "version": "3.0",
  "device_company": "demo",
  "board": "demo_board",
  "target_cpu": "arm",
  "kernel_type": "liteos_m",
  "kernel_version": "3.0.0",
  "subsystems":
  [
    {
      "subsystem": "kernel",
      "components": 
      [
        {
          "component": "liteos_m", 
          "features": []
        }
      ]
    }
  ],
  "vendor_adapter_dir": "",
  "product_adapter_dir": "",
  "third_party_dir": "//third_party"
}

这个时候用hb set就能选择hello了。但是会报错：

OHOS Which product do you need?  hello
[OHOS ERROR] invalid path: /home/openharmony/device/board/demo/demo_board

没关系因为我们device目录还没有东西，要按照规则创建/device/board/demo/demo_board。继续报错：

STM32F407移植OpenHarmony笔记2

Wed, 24 Jan 2024 16:01:50 +0000

接上篇，搭建完开发环境后，我们还要继续工作。

官方合作的开发板刚好有STM32F407，我准备试一下开发板的demo，虽然我用的不是他们的开发板。

先下载以下3份代码：

https://gitee.com/openharmony/device_board_talkweb/tree/OpenHarmony-v3.2-Beta5/
https://gitee.com/openharmony/vendor_talkweb/tree/OpenHarmony-v3.2-Beta5/
https://gitee.com/openharmony/device_soc_st/tree/OpenHarmony-v3.2-Beta5/

device_board_talkweb下载后，要解压到：//device/board/talkweb device_talkweb下载后，要解压到：//vendor/talkweb device_soc_st下载后，要解压到：//device/soc/st

准备好后，我们再运行hb set可以在列表里看到talkweb的信息,选中niobe407。

根据开发板的文档，还要进入kernel/liteos_m，进行make menuconfig选择board和applications。

然后执行hb build编译试一下。

编译成功后，就在out下面能找到OHOS_Image.bin

用JLINK下载OHOS_Image.bin后，串口什么反应也没有。

由于硬件差异，需要根据自己的硬件来修改时钟配置和串口引脚。

修改里面的参数。

/device/board/talkweb/niobe407/liteos_m/bsp/src/main.c

主要是PLL和GPIO。

//板子晶振是25M的，如下修改
#define BAUDRATE 115200
#define NIOBE_PLLM 25
#define NIOBE_PLLN 336
#define NIOBE_PLLQ 7
#define NIOBE_DELAY 1000

修改后，再次编译下载，还是没有反应。

经过一番调查后，发现这demo还编译了一个bootloader，这个bootloader什么也没做，只负责跳转到0x08010000。

参见：/device/board/talkweb/niobe407/liteos_m/bootloader/src/bootloader.c

最终bootloader合并app后，生成的文件名是:OHOS_Image_allinone.bin

用JLINK下载这个bin文件，终于在串口看到日志打印信息了。

*************************************************************

████████╗ █████╗ ██╗     ██╗  ██╗██╗    ██╗███████╗██████╗
╚══██╔══╝██╔══██╗██║     ██║ ██╔╝██║    ██║██╔════╝██╔══██╗
   ██║   ███████║██║     █████╔╝ ██║ █╗ ██║█████╗  ██████╔╝
   ██║   ██╔══██║██║     ██╔═██╗ ██║███╗██║██╔══╝  ██╔══██╗
   ██║   ██║  ██║███████╗██║  ██╗╚███╔███╔╝███████╗██████╔╝
   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ ╚══════╝╚═════╝

         Welcome to use Niobe407 development board!
             Hardware version: 1.0.0
             Software version: 1.0.0
*************************************************************
entering kernel init...
hilog will init.
hievent will init.

hievent init success.
Entering scheduler
hiview init success.
[HDF:E/HDF_LOG_TAG]DeviceManagerStart in
printf error!
printf error!
[HDF:I/gpio_manager]GpioManagerAdd: start:0 count:6 added success
[HDF:D/HDF_LOG_TAG]PlatformManagerAddDevice: add dev:(null)(0) to PLATFORM_MODULE_GPIO success
[HDF:D/HDF_LOG_TAG]PlatformDeviceAdd: add dev:(null)(0) success

虽然到此代码在我的STM32F407上面跑起来了，但还有满脑子问号需要进一步学习和调查。

STM32F407移植OpenHarmony笔记1

Wed, 24 Jan 2024 15:16:48 +0000

参考文档：

OpenAtom OpenHarmony

搭建环境

安装linux系统:

Ubuntu 22.04.2 LTS (GNU/Linux 5.15.0-91-generic x86_64)

下载源代码：我选择的是V3.2.4版本

https://repo.huaweicloud.com/openharmony/os/3.2.4/code-v3.2.4-Release_20231113.tar.gz

安装docker：

sudo apt install docker.io

下载docker镜像：单片机用的是轻量系统，因此选择对应的mini镜像

sudo docker pull swr.cn-south-1.myhuaweicloud.com/openharmony-docker/docker_oh_mini:3.2

创建docker容器：给它取个别名叫ohos3,以后记得都用它，避免每次都重新创建新容器。 -v $(pwd):/home/openharmony参数是把当前目录映射到容器内的/home/openharmony。

#创建并运行docker
sudo docker run --name ohos3 -it -v $(pwd):/home/openharmony swr.cn-south-1.myhuaweicloud.com/openharmony-docker/docker_oh_mini:3.2
#当需要重新进入docker的时候用：
sudo docker start -ai ohos3

后续代码编译都是在docker内进行。

验证环境：

解压源码:

tar -xvf ./code-v3.2.4-Release_20231113.tar.gz

进入源码根目录：

OpenHarmony-v3.2.4-Release/OpenHarmony

安装hb工具：

默认情况下，用官方文档的方法：python3 build.py -p {product_name}@{company}是编译不了的。需要安装hb，后续也建议用hb命令来编译。

pip install --user build/lite

安装成功后，输入hb，可以看到命令提示：

root@46010c9c023d:/home/openharmony# hb
usage: -c [-h] [-v] {build,set,env,clean,tool} ...

OHOS Build System version 0.4.6

positional arguments:
  {build,set,env,clean,tool}
    build               Build source code
    set                 OHOS build settings
    env                 Show OHOS build env
    clean               Clean output
    tool                Call the gn command through the hb tool

optional arguments:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit

编译测试：用hb set选择要编译的目标，然后执行build，我们先测试qemu_mini_system_demo

解决VSCode使用SSH远程连接时无法指定用户名的问题

Wed, 01 Nov 2023 14:34:21 +0000

Windows 11自带OpenSSH客户端，和VSCode配合得很好，没有这个问题。

今天要说的是旧版本Windows 7/8/10系统遇到的问题。

PS: Windows 7可以运行的最后版本是VSCode 1.80.2

由于Windows 7/8/10没有自带的OpenSSH客户端，但可以调用MSYS环境下的ssh。我制作的MSYS绿色版，有需要的可以下载：百度网盘请输入提取码 :jbe8 如下图所示，修改SSH:Path

默认设置下，通过Remote Explorer添加远程主机时，无法指定登陆用户名，它总是以Administrator账户登陆。

在VSCode 1.80版本以前，我发现可以使用下面的方式添加SSH远程连接，添加远程主机时,把用户名写在前面。如下图所示myname就是登陆的用户名。

但是VSCode版本更新到1.80以后，这种方式不起作用了，会提示如下错误：

后来经过研究，找到了无法改变用户名的根本原因，也就能解决1.80以后的这个问题。

原因是我们调用的MSYS的ssh,它只会加载MSYS/home/Administrator/.ssh/config这个文件，而不是VSCode里面默认的那个config文件。

因此我们只需要在VSCode设置里面，把config文件路径修改为MSYS下面的就可以啦！

现在我们就能正常使用VSCode添加远程主机和指定登陆用户名了。

如下图：一个正常的config文件内容

解释 Git 的基本概念

Mon, 28 Aug 2023 09:01:39 +0000

Git是一种分布式版本控制系统，用于管理代码和其他项目文件的版本，以及协调多个开发者对同一项目的工作。以下是Git的主要概念和使用方式：

仓库（Repository）：用于存储和管理项目代码和文件的地方，可以是本地仓库或远程仓库。
提交（Commit）：将更改保存到Git仓库中的过程。一个提交包含一组文件更改，每次提交都会生成一个唯一的SHA值。
分支（Branch）：用于并行开发的独立的代码分支。主分支通常称为主干（Master），可以基于主干创建其他分支，在分支上进行更改和提交，最终将更改合并回主干。
合并（Merge）：将一个分支的更改合并到另一个分支的过程。可以手动合并或使用Git自动合并工具。
远程仓库（Remote）：在互联网上托管的Git仓库，用于多人协作和备份。
克隆（Clone）：从远程仓库中复制代码到本地计算机的过程。可以使用Git URL或HTTP URL进行克隆。
拉取（Pull）：从远程仓库获取更新并将其合并到本地仓库的过程。
推送（Push）：将本地代码更改推送到远程仓库的过程。
标签（Tag）：用于标记在代码库中的特定状态，通常用于发布版本。

使用Git，可以在本地计算机上创建一个仓库，进行更改和提交，并将更改推送到远程仓库。也可以通过克隆远程仓库并在本地计算机上工作，将更改推送回远程仓库。还可以使用分支进行并行开发，并使用合并将更改合并回主干。Git提供了强大的版本控制和协作功能，使多人协作和代码管理变得更加容易和可靠。

以上内容由AI创作助手根据用户提示词生成。

SNMP协议中OID的编码规则

Mon, 17 Jul 2023 14:56:32 +0000

前言

SNMP协议基于UDP，代理软件（服务器）监听161端口，管理端（客户端）监听162端口。

正常请求：管理端发送请求到161端口，代理软件收到请求后将数据返回给管理端源端口。主动上报：代理软件主动把数据发送管理端的162端口。

SNMP协议中请求数据主要是读和写操作。每个操作会有一个目标对象，这个对象用OID来表示。 OID是用一串数字表示：比如.1.3.6.1.2.1.1.5表示设备名称。并且父子节点之间用小数点(.)分隔，形成类似于文件夹的树形结构。

本文主要介绍OID的编码和解码规则。

编码：.1.3.6.1.2.1.1.5在UDP报文中是怎么表达的？

解码：我收到一串UDP报文，如何解析出它的OID值是多少？

设备名称＝ .1.3.6.1.2.1.1.5 ＝ 0x2B, 0x06, 0x01, 0x02, 0x01, 0x01, 0x05

编码规则：

最开始的2个数字.1.3是特殊规则，编码固定值：0x2B 其后面的每个OID节点数值都用一个或多个字节来表示。如果这个值小于128，最简单的情况就用1个字节。如果大于128则需要用多个字节：对OID进行128整除，如果商大于128则继续整除，直到商小于128，则记为第1字节。对余数重复上面的操作，将产生第2,3,4…字节，直到余数小于128，此时的余数记为最后1字节。最后除了最后1字节外，前面的所有字节都要把最高位置1。

文字表达可能并不容易理解，下面多举几个例子就很容易理解了：

OID：.1.3.6.1.2.1.1.5

HEX：0x2B, 0x06, 0x01, 0x02, 0x01, 0x01, 0x05
所有数字都小于128，每个数字直接用1字节表示。

OID：.1.3.6.1.2.1.255.5

HEX: 0x2B, 0x06, 0x01, 0x02, 0x01, 0x81, 0x7F, 0x05 
由于255大于128，需要分解为多个字节：
255 = 128 * 1 + 127（商为1，余数为127，所以用2个字节表示：0x81（高位置1）, 0x7F）

OID： .1.3.6.1.2.1.255.99999

HEX: 0x2B, 0x06, 0x01, 0x02, 0x01, 0x81, 0x7F, 0x86, 0x8D, 0x1F 
255 = 128 * 1 + 127（0x81, 0x7F）
99999 = 128 * 128 * 6 + 128 * 13 + 31（0x86，0x8D, 0x1F）

OID：.1.3.6.1.2.1.255.99999.4294967295

android系统中定义的按键码(包含键盘，游戏手柄，TV遥控器)

Wed, 31 May 2023 17:55:20 +0000

数据来源：android sdk.

KEYCODE_UNKNOWN	0
KEYCODE_SOFT_LEFT	1
KEYCODE_SOFT_RIGHT	2
KEYCODE_HOME	3
KEYCODE_BACK	4
KEYCODE_CALL	5
KEYCODE_ENDCALL	6
KEYCODE_0	7
KEYCODE_1	8
KEYCODE_2	9
KEYCODE_3	10
KEYCODE_4	11
KEYCODE_5	12
KEYCODE_6	13
KEYCODE_7	14
KEYCODE_8	15
KEYCODE_9	16
KEYCODE_STAR	17
KEYCODE_POUND	18
KEYCODE_DPAD_UP	19
KEYCODE_DPAD_DOWN	20
KEYCODE_DPAD_LEFT	21
KEYCODE_DPAD_RIGHT	22
KEYCODE_DPAD_CENTER	23
KEYCODE_VOLUME_UP	24
KEYCODE_VOLUME_DOWN	25
KEYCODE_POWER	26
KEYCODE_CAMERA	27
KEYCODE_CLEAR	28
KEYCODE_A	29
KEYCODE_B	30
KEYCODE_C	31
KEYCODE_D	32
KEYCODE_E	33
KEYCODE_F	34
KEYCODE_G	35
KEYCODE_H	36
KEYCODE_I	37
KEYCODE_J	38
KEYCODE_K	39
KEYCODE_L	40
KEYCODE_M	41
KEYCODE_N	42
KEYCODE_O	43
KEYCODE_P	44
KEYCODE_Q	45
KEYCODE_R	46
KEYCODE_S	47
KEYCODE_T	48
KEYCODE_U	49
KEYCODE_V	50
KEYCODE_W	51
KEYCODE_X	52
KEYCODE_Y	53
KEYCODE_Z	54
KEYCODE_COMMA	55
KEYCODE_PERIOD	56
KEYCODE_ALT_LEFT	57
KEYCODE_ALT_RIGHT	58
KEYCODE_SHIFT_LEFT	59
KEYCODE_SHIFT_RIGHT	60
KEYCODE_TAB	61
KEYCODE_SPACE	62
KEYCODE_SYM	63
KEYCODE_EXPLORER	64
KEYCODE_ENVELOPE	65
KEYCODE_ENTER	66
KEYCODE_DEL	67
KEYCODE_GRAVE	68
KEYCODE_MINUS	69
KEYCODE_EQUALS	70
KEYCODE_LEFT_BRACKET	71
KEYCODE_RIGHT_BRACKET	72
KEYCODE_BACKSLASH	73
KEYCODE_SEMICOLON	74
KEYCODE_APOSTROPHE	75
KEYCODE_SLASH	76
KEYCODE_AT	77
KEYCODE_NUM	78
KEYCODE_HEADSETHOOK	79
KEYCODE_FOCUS	80 // Camera focus
KEYCODE_PLUS	81
KEYCODE_MENU	82
KEYCODE_NOTIFICATION	83
KEYCODE_SEARCH	84
KEYCODE_MEDIA_PLAY_PAUSE= 85
KEYCODE_MEDIA_STOP	86
KEYCODE_MEDIA_NEXT	87
KEYCODE_MEDIA_PREVIOUS	88
KEYCODE_MEDIA_REWIND	89
KEYCODE_MEDIA_FAST_FORWARD	90
KEYCODE_MUTE	91
KEYCODE_PAGE_UP	92
KEYCODE_PAGE_DOWN	93
KEYCODE_PICTSYMBOLS	94 // switch symbol-sets (Emoji,Kao-moji)
KEYCODE_SWITCH_CHARSET	95 // switch char-sets (Kanji,Katakana)
KEYCODE_BUTTON_A	96
KEYCODE_BUTTON_B	97
KEYCODE_BUTTON_C	98
KEYCODE_BUTTON_X	99
KEYCODE_BUTTON_Y	100
KEYCODE_BUTTON_Z	101
KEYCODE_BUTTON_L1	102
KEYCODE_BUTTON_R1	103
KEYCODE_BUTTON_L2	104
KEYCODE_BUTTON_R2	105
KEYCODE_BUTTON_THUMBL	106
KEYCODE_BUTTON_THUMBR	107
KEYCODE_BUTTON_START	108
KEYCODE_BUTTON_SELECT	109
KEYCODE_BUTTON_MODE	110
KEYCODE_ESCAPE	111
KEYCODE_FORWARD_DEL	112
KEYCODE_CTRL_LEFT	113
KEYCODE_CTRL_RIGHT	114
KEYCODE_CAPS_LOCK	115
KEYCODE_SCROLL_LOCK	116
KEYCODE_META_LEFT	117
KEYCODE_META_RIGHT	118
KEYCODE_FUNCTION	119
KEYCODE_SYSRQ	120
KEYCODE_BREAK	121
KEYCODE_MOVE_HOME	122
KEYCODE_MOVE_END	123
KEYCODE_INSERT	124
KEYCODE_FORWARD	125
KEYCODE_MEDIA_PLAY	126
KEYCODE_MEDIA_PAUSE	127
KEYCODE_MEDIA_CLOSE	128
KEYCODE_MEDIA_EJECT	129
KEYCODE_MEDIA_RECORD	130
KEYCODE_F1	131
KEYCODE_F2	132
KEYCODE_F3	133
KEYCODE_F4	134
KEYCODE_F5	135
KEYCODE_F6	136
KEYCODE_F7	137
KEYCODE_F8	138
KEYCODE_F9	139
KEYCODE_F10	140
KEYCODE_F11	141
KEYCODE_F12	142
KEYCODE_NUM_LOCK	143
KEYCODE_NUMPAD_0	144
KEYCODE_NUMPAD_1	145
KEYCODE_NUMPAD_2	146
KEYCODE_NUMPAD_3	147
KEYCODE_NUMPAD_4	148
KEYCODE_NUMPAD_5	149
KEYCODE_NUMPAD_6	150
KEYCODE_NUMPAD_7	151
KEYCODE_NUMPAD_8	152
KEYCODE_NUMPAD_9	153
KEYCODE_NUMPAD_DIVIDE	154
KEYCODE_NUMPAD_MULTIPLY	155
KEYCODE_NUMPAD_SUBTRACT	156
KEYCODE_NUMPAD_ADD	157
KEYCODE_NUMPAD_DOT	158
KEYCODE_NUMPAD_COMMA	159
KEYCODE_NUMPAD_ENTER	160
KEYCODE_NUMPAD_EQUALS	161
KEYCODE_NUMPAD_LEFT_PAREN	162
KEYCODE_NUMPAD_RIGHT_PAREN	163
KEYCODE_VOLUME_MUTE	164
KEYCODE_INFO	165
KEYCODE_CHANNEL_UP	166
KEYCODE_CHANNEL_DOWN	167
KEYCODE_ZOOM_IN	168
KEYCODE_ZOOM_OUT	169
KEYCODE_TV	170
KEYCODE_WINDOW	171
KEYCODE_GUIDE	172
KEYCODE_DVR	173
KEYCODE_BOOKMARK	174
KEYCODE_CAPTIONS	175
KEYCODE_SETTINGS	176
KEYCODE_TV_POWER	177
KEYCODE_TV_INPUT	178
KEYCODE_STB_POWER	179
KEYCODE_STB_INPUT	180
KEYCODE_AVR_POWER	181
KEYCODE_AVR_INPUT	182
KEYCODE_PROG_RED	183
KEYCODE_PROG_GREEN	184
KEYCODE_PROG_YELLOW	185
KEYCODE_PROG_BLUE	186
KEYCODE_APP_SWITCH	187
KEYCODE_BUTTON_1	188
KEYCODE_BUTTON_2	189
KEYCODE_BUTTON_3	190
KEYCODE_BUTTON_4	191
KEYCODE_BUTTON_5	192
KEYCODE_BUTTON_6	193
KEYCODE_BUTTON_7	194
KEYCODE_BUTTON_8	195
KEYCODE_BUTTON_9	196
KEYCODE_BUTTON_10	197
KEYCODE_BUTTON_11	198
KEYCODE_BUTTON_12	199
KEYCODE_BUTTON_13	200
KEYCODE_BUTTON_14	201
KEYCODE_BUTTON_15	202
KEYCODE_BUTTON_16	203
KEYCODE_LANGUAGE_SWITCH	204
KEYCODE_MANNER_MODE	205
KEYCODE_3D_MODE	206
KEYCODE_CONTACTS	207
KEYCODE_CALENDAR	208
KEYCODE_MUSIC	209
KEYCODE_CALCULATOR	210
KEYCODE_ZENKAKU_HANKAKU	211
KEYCODE_EISU	212
KEYCODE_MUHENKAN	213
KEYCODE_HENKAN	214
KEYCODE_KATAKANA_HIRAGANA	215
KEYCODE_YEN	216
KEYCODE_RO	217
KEYCODE_KANA	218
KEYCODE_ASSIST	219
KEYCODE_BRIGHTNESS_DOWN	220
KEYCODE_BRIGHTNESS_UP	221
KEYCODE_MEDIA_AUDIO_TRACK	222
KEYCODE_SLEEP	223
KEYCODE_WAKEUP	224
KEYCODE_PAIRING	225
KEYCODE_MEDIA_TOP_MENU	226
KEYCODE_11	227
KEYCODE_12	228
KEYCODE_LAST_CHANNEL	229
KEYCODE_TV_DATA_SERVICE	230
KEYCODE_VOICE_ASSIST	231
KEYCODE_TV_RADIO_SERVICE	232
KEYCODE_TV_TELETEXT	233
KEYCODE_TV_NUMBER_ENTRY	234
KEYCODE_TV_TERRESTRIAL_ANALOG	235
KEYCODE_TV_TERRESTRIAL_DIGITAL	236
KEYCODE_TV_SATELLITE	237
KEYCODE_TV_SATELLITE_BS	238
KEYCODE_TV_SATELLITE_CS	239
KEYCODE_TV_SATELLITE_SERVICE	240
KEYCODE_TV_NETWORK	241
KEYCODE_TV_ANTENNA_CABLE	242
KEYCODE_TV_INPUT_HDMI_1	243
KEYCODE_TV_INPUT_HDMI_2	244
KEYCODE_TV_INPUT_HDMI_3	245
KEYCODE_TV_INPUT_HDMI_4	246
KEYCODE_TV_INPUT_COMPOSITE_1	247
KEYCODE_TV_INPUT_COMPOSITE_2	248
KEYCODE_TV_INPUT_COMPONENT_1	249
KEYCODE_TV_INPUT_COMPONENT_2	250
KEYCODE_TV_INPUT_VGA_1	251
KEYCODE_TV_AUDIO_DESCRIPTION	252
KEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP	253
KEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN	254
KEYCODE_TV_ZOOM_MODE	255
KEYCODE_TV_CONTENTS_MENU	256
KEYCODE_TV_MEDIA_CONTEXT_MENU	257
KEYCODE_TV_TIMER_PROGRAMMING	258
KEYCODE_HELP	259
KEYCODE_NAVIGATE_PREVIOUS	260
KEYCODE_NAVIGATE_NEXT	261
KEYCODE_NAVIGATE_IN	262
KEYCODE_NAVIGATE_OUT	263
KEYCODE_STEM_PRIMARY	264
KEYCODE_STEM_1	265
KEYCODE_STEM_2	266
KEYCODE_STEM_3	267
KEYCODE_DPAD_UP_LEFT	268
KEYCODE_DPAD_DOWN_LEFT	269
KEYCODE_DPAD_UP_RIGHT	270
KEYCODE_DPAD_DOWN_RIGHT	271
KEYCODE_MEDIA_SKIP_FORWARD	272
KEYCODE_MEDIA_SKIP_BACKWARD	273
KEYCODE_MEDIA_STEP_FORWARD	274
KEYCODE_MEDIA_STEP_BACKWARD	275
KEYCODE_SOFT_SLEEP	276
KEYCODE_CUT	277
KEYCODE_COPY	278
KEYCODE_PASTE	279
KEYCODE_SYSTEM_NAVIGATION_UP	280
KEYCODE_SYSTEM_NAVIGATION_DOWN	281
KEYCODE_SYSTEM_NAVIGATION_LEFT	282
KEYCODE_SYSTEM_NAVIGATION_RIGHT	283
KEYCODE_ALL_APPS	284
KEYCODE_REFRESH	285
KEYCODE_THUMBS_UP	286
KEYCODE_THUMBS_DOWN	287
KEYCODE_PROFILE_SWITCH	288
KEYCODE_VIDEO_APP_1	289
KEYCODE_VIDEO_APP_2	290
KEYCODE_VIDEO_APP_3	291
KEYCODE_VIDEO_APP_4	292
KEYCODE_VIDEO_APP_5	293
KEYCODE_VIDEO_APP_6	294
KEYCODE_VIDEO_APP_7	295
KEYCODE_VIDEO_APP_8	296
KEYCODE_FEATURED_APP_1	297
KEYCODE_FEATURED_APP_2	298
KEYCODE_FEATURED_APP_3	299
KEYCODE_FEATURED_APP_4	300
KEYCODE_DEMO_APP_1	301
KEYCODE_DEMO_APP_2	302
KEYCODE_DEMO_APP_3	303
KEYCODE_DEMO_APP_4	304

FBAlpha编译和裁剪笔记

Wed, 24 May 2023 16:20:47 +0000

FBAlpha是一个开源的街机游戏模拟器.链接：http://www.fbalpha.com/

每个版本都会发布Windows Binary文件和源代码，目前新版本为0.2.97.39.

原版程序支持的游戏非常多，但是在搜索ROM的时候，速度非常慢，于是产生了裁剪的想法！主要想解决搜索ROM速度过慢的问题.

从官方文档了解到，可以在Windows环境下使用mingw进行编译.需要依次下载以下文件：

1.从官网下载源码包.

下载地址：http://static.fbalpha.com/files/fba_src_029739.7z

2.下载MINGW

官方推荐使用：http://tdm-gcc.tdragon.net/

我下载的版本是tdm64-gcc-5.1.0-2.exe

3.下载binutil

下载地址：http://www.fbalpha.com/files/gnu_utils.zip

解压到MINGW/BIN目录下

4.下载NASM

下载地址：http://www.nasm.us/pub/nasm/releasebuilds/2.11.08/win32/nasm-2.11.08-win32.zip

解压到MINGW/BIN目录

5.安装Perl

下载地址：http://www.activestate.com/activeperl/

我下载的是ActivePerl-5.24.1.2402-MSWin32-x86-64int-401627.exe

准备工作做好了，就可以开始编译了！

切换到源码目录下面，打开命令行，输入mingw32-make mingw510就可以编译了,大约5－10分钟可以看到生成fba.exe文件.

编译环境弄好了，就可以研究一下代码了，fba搜索ROM需要搜索20个文件夹！搜索的游戏有几千个，依次查找对应的zip文件，

所以可以考虑删除那些不需要的游戏驱动，提高搜索速度的同时还可以减少exe文件的体积.

游戏驱动在 src\burn\drv 目录下面，我只保留CPS1/2/3, NEOGEO, PGM，其它的驱动全部删除掉。再次编译报错，找不到文件依赖项。

打开makefile.burn_rules,打到那些被我删除的依赖项，删除掉，再重新编译，通过了！

这下fba.exe体积从原版的25MB缩小到了8M，再打开ROM搜索界面，搜索速度也变快了，非常好！

编译正常，还可以进行一些其它修改.比如：

1.ROM路径配置对话框，太难用了. 界面相关的代码在src/burner/win32目录下，资源文件是app.rc，可以修改对话框，菜单的布局.

2.原版创建的文件夹太多了，可以去掉那些没用的文件夹，在src/burner/win32/main.cpp 可以看到创建了一堆文件夹.

3.默认NEOGEO的BIOS为英语，可以修改为日版，在src/burn/drv/neogeo/d_neogeo.c，第569行，倒数第二个值，原版为0x80，修改为0x8a.

修改之后像战国传承3这类游戏就可以看到日文界面了。

4………..

附上我精简过后的源代码： fba_lite: FBA模拟器精简版.

apktool打包失败

Sat, 29 Apr 2023 00:06:35 +0000

报错信息：

invalid resource directory name: res navigation brut.androlib.AndrolibException: brut.common.BrutException: could not exec…

在解包时如果加上-r参数，不反编译资源，则重打包没有问题。试试下面的命令打包：

打包时添加--use-aapt2参数：
apktool b --use-aapt2 dir

APK安装失败:Failed to extract native libraries

Fri, 28 Apr 2023 23:59:55 +0000

APK使用apktool重新编译后安装失败。

错误提示：Failure [INSTALL_FAILED_INVALID_APK: Failed to extract native libraries, res=-2]

可能是因为AndroidManifest.xml 中设置 extractNativeLibs= false导致的，将其修改为true。

参考资料： Failure [INSTALL_FAILED_INVALID_APK: Failed to extract native libraries, res=-2] · TesterHome

把TKStudio改造为一个小巧的代码编辑器

Fri, 03 Feb 2023 10:08:46 +0000

TKStudio是周立功公司开发的一款嵌入式集成开发环境，功能挺强大的。通过外挂编译器的形式支持8051，430，ARM等各种内核的软件编译和调试。同时还支持SSH远程调试，LINUX内核裁剪等一大堆实用工具，看得出来开发这套软件应该要耗费不少时间和精力！可惜2012年发布5.0版本之后就停止维护了，实在有点可惜。

大学期间用TKStudio用得比较多，最大感受就是代码编辑功能很强大，拥有代码染色，参数补全，智能提示等，秒杀当时的IAR和Keil。最顺手的功能就是工程目录可以直接导入文件夹，自动生成代码目录树，非常方便！而KEIL和IAR则只能手动建立目录树，对于代码文件夹很多的工程来说，非常麻烦。

最近要阅读一个linux社区的开源软件，解压后没有工程文件，用Notepad++一个一个地打开源码又太繁琐，而电脑又很久没有安装Source Insight了，突然想到多年前的TKStudio软件，于是心血来潮折腾一下，看看能不能改造利用一下。

如下图：使用导入文件夹功能，自动生成的代码树，查看这种开源代码实用性很高。

确认软件功能没问题后，可以着手改造了，安装完整版软件后，目录结构如下，整个文件夹有1.0GB。

里面大部分文件都是编译器和调试器相关的组件，我想着应该可以删掉大部分，只保留代码编辑的功能。

说干就干，经过一番分析，此软件的模块化设计做的还不错，很多文件可以直接删掉不影响主程序功能。而且还有mcudev.ini负责软件的安装配置，手动修改该文件可以去掉很多无用的模块。比如： build目录下面是各种编译器的配置选项对话框，可以通过修改mcudev.ini来选择性的使用。 DN目录下面是开发手册，类似于MSDN一样的帮助文件。 EStype是代码染色方案配置 opt是编译器全局选项的配置文件 skin是图片资源，其中splash.png启动LOGO 其它文件夹都是可以直接删除的。而根目录下面的一大堆DLL文件，通过测试发现很多都是可以删除的。 TKStudio.cbd是支持的MCU设备列表，可以手动删除，只保留一个就可以了，因为新建工程的时候，必须要选择一个MCU型号。 langs.xml和native.xml两个分别是代码染色的配置和中文化界面语言配置文件，从这两个文件可以看出TKStudio的代码编辑功能相关代码直接引用了Notepad++的部分源码。

最终精简后，得到一个只保留代码编辑功能的软件，文件夹体积只有13MB！很小巧吧！最终的目录结构如下：

我也将最终的软件，打包上传到CSDN了，有兴趣的同学可以自行下载体验： TKStudio可代替SourceInsight的代码编辑器_TKStudio-C文档类资源-CSDN下载

#2023更新 上次打包少了个文件，启动时会警告弹窗。现在重新打包，解决问题。同时添加了一个TKStudio.reg文件，默认的主页布局很乱，可以导入这个注册表文件快速恢复。请下载下面的文件：文件分享

PLMN=46004是中国移动的SIM卡

Mon, 30 Jan 2023 09:12:34 +0000

今天遇到一张SIM卡，其IMSI号码是46004开头的，导致自动识别运营商失败.

百度搜索到的资料都没有说明46004是哪家运营商，经过一番仔细搜索发现网上的资料比较老。

后再来工信部网站找到了2017年发布的通告，46004是分配给中国移动的。

顺便记录一下目前已分配的PLMN（MCC+MNC）号段。

1.号码结构

ITU-T E.212国际移动用户识别码(IMSI)是在数字公用陆地蜂窝移动通信网中唯一地识别一个移动用户的号码，其结构如图2所示，最长位数为15位，目前我国IMSI的位数为所允许的最长位数，即为一个15位数字的号码。

IMSI由三部分组成：

移动国家号码MCC：由3个数字组成，唯一地识别移动用户所属的国家，中国为460；

移动网络识别码MNC：识别移动用户所归属的移动网，中国采用2位；

移动用户识别码MSIN：唯一地识别移动通信网中的移动用户，中国采用10位。

2.移动网络识别码（MNC）的规划和分配情况

移动网络识别码MNC	使用单位
00	中国移动
01	中国联通
02	中国移动
03	中国电信
04	中国移动
06	中国联通
07	中国移动
08	中国移动
09	中国联通
10	中国联通
11	中国电信
12	中国电信
1X（X=3～9）	根据需要核配启用
2X（X=0～9）	中国移动

（根据需要核配启用） | | 3X（X=0～9） | 中国联通

（根据需要核配启用） | | 4X（X=0～9） | 备用 | | 5X（X=0～9） | 中国电信

（根据需要核配启用） | | 6X～9X（X=0～9） | 备用 |

资料来源：工业和信息化部关于发布《电信网编号计划（2017年版）》的通告

常见分组加密算法和加密模式

Thu, 05 Jan 2023 20:32:16 +0000

加密算法

DES

DES算法是1972年由IBM设计的，然后被美国政府选为标准加密算法。分组大小64位，缺点是密钥较短，只有56位，抵抗破解的能力较弱，后来有了3DES。

3DES

3DES算法1981年从DES发展而来，对一块数据用3个不同的密钥进行3次DES加密，强度更高。不过3DES的计算量较大，效率较低。在密钥长度、迭代次数等方面难以扩展，所以有了AES。

AES

AES前身是Rijndael算法，由1997年美国国家标准与技术研究院（NIST）的公开邀请而创建。 NIST通过公开选拔挑选出来作为国家标准的加密算法，2000年正式成为高级加密标准（AES）。分组大小固定为128位，支持128、192、256、512位密钥的加密。优点是速度快，安全级别高，是目前最常见的对称加密算法。

Blowfish

Blowfish是由Bruce Schneier于1993年开发的，最初目的是替代DES，它采用和DES相同的分组大小64位，但密钥长度可扩展32－448位。其安全性并不弱于AES，但不如AES知名度高。

Camellia

Camellia算法由三菱和日本电信电话（NTT）在2000年共同发明，2003年入选欧洲NESSIE工程。 Camellia算法的分组长度为128位，密钥长度可以使用128、192或256位。具有与AES同等级的安全强度及运算量。

ARIA

ARIA是韩国Daesung Kwon等提出的一种分组密码算法， ARIA于2004年确认为韩国标准分组密码算法。 ARIA算法的分组长度为128位，密钥长度可变，可取128、192或256位。

加密模式

加密模式在分组加密中用来对每个分组的数据进行调整，包括填充以提高数据整体的安全性。常用的模式有以下一些：

ECB（Electronic Codebook Mode） ECB是最简单和最基本的模式，对每个分组使用相同的方式加密，相同的明文数据块会被加密成相同的密文，降低了破解的难度，所以实际应用中很少使用。

CBC（Cipher Block Chaining Mode） CBC模式中，每个数据块加密时直接使用明文跟上个数据块加密后产生的密文或初始向量进行异或，再与密钥进行加密，得到密文。它的缺点是不利于并行、传递误差、需要初始化向量。

OFB（Output Feedback Mode） 每个数据块加密过程中的中间输出会反馈到下个数据块的加密过程中。缺点跟CBC类似。

CFB（Cipher Feedback Mode） 每个数据块加密产生的密文会反馈到下个数据块的加密过程中。缺点跟CBC类似。

CTR（Counter Mode） 用密钥对输入的计数器加密，然后跟明文异或得到密文。优点是可以并行，避免误差传递问题。缺点是可以针对单个数据块进行攻击。

CCM（Counter with CBC-MAC Mode） CCM是在CBC和CTR的基础上增加CMAC算法校验，主要是通过MAC校验来解决CTR容易被攻击的问题。

GCM（Galois/Counter Mode） GCM是在CCM的基础上改用GMAC算法代替CMAC算法，增加了并行化设计，可以提高加密性能，降低时延。

虽然加密模式有很多种，但现在有实用价值的还是CCM和GCM两种。这两种也是TLS 1.3唯二使用的AES加密算法。

Marvell交换机芯片SMI接口读写协议

Wed, 14 Dec 2022 17:39:17 +0000

Marvell的88E6XXX系列交换机芯片基本都提供SMI（Serial Management Interface）接口。 SMI接口使用2线串行通信，一个MDC提供时钟，一个MDIO为双向数据引脚。外部CPU通过这2个引脚访问芯片内部的寄存器。

SMI接口的通信时序如图所示：

开始通信前要发送32个时钟做为前导帧，操作结束后同样也发送32个时钟作为空闲。空闲期间MDIO引脚保持高电平。

通信数据包含： 2bit起始位， 2bit读写操作码， 5bit设备地址， 5bit寄存器地址， 2bit读写转换， 16bit寄存器数据。

SMI寻址方式又分为2种，单芯片模式和多芯片模式。

单芯片模式： 是直接通过读写命令访问内部寄存器。

多芯片模式： 多个芯片并联在同一条SMI总线上，类似于I2C，通过芯片地址来访问。由于多了一个芯片地址，只能以间接的方式访问内部寄存器。 此时的设备地址是芯片地址，寄存器地址只能是0x00或0x01。 把要访问的内部寄存器地址和设备地址写入0x00(Command Register)，把要写入的数据写入0x01(Data Register)，或者从0x01(Data Register)读出内部数据。

如图所示：Command Register的bit[9:5]写入的是设备地址，这个地址就是单芯片模式的SMI设备地址，bit[4:0]写入的是寄存器地址，和单芯片模式的SMI寄存器地址一样。

然后读回Command Register的bit15，如果为0表示操作完成，此时可以从Data Register读回数据。

芯片内部寄存器地址解读： 如下图所示，是某芯片手册里的寄存器地址表。顶部的0到1D表示设备地址。左侧的0到1F是寄存器地址。比如设备地址10，寄存器地址0，那就是Port Status（端口1的状态）。

MODBUS-ASCII协议

Mon, 12 Dec 2022 09:54:16 +0000

MODBUS协议在RS485总线上有RTU和ASCII两种传输格式。

其中ASCII协议应用比较少，主要还是以RTU格式为主。

相比较于RTU的2进制传输，ASCII使用的是文本传输， 整个数据包都是可打印字符。

下面是示例：

:010300000001FB\r\n

帧头是冒号(:)，帧尾是换行符(\r\n)，掐头去尾得到有效数据：

010300000001FB

我们再把字符串转换为16进制就得到：

0x01，0x03，0x00，0x00，0x00，0x01，0xFB

0x01是设备地址，0x03是功能码，0x0000是寄存器地址，0x0001是寄存器数量，0xFB是校验。

由些可见，ASCII帧格式虽然与RTU有所差别，但是功能码和寄存器格式是一样的。

唯一不同的是校验位，ASCII格式使用的是LRC校验算法，RTU格式使用的是CRC16校验算法。

下面是校验位的算法：

0xFB = (~(0x01 + 0x03 + 0x00 + 0x00 + 0x00 + 0x01) + 1) & 0xFF

再举一个例子，生成一条数据包：

设备地址为0x10，我要用06功能码写0x0001寄存器，值为0xABCD。

首先是生成命令字节：

0x10，0x06，0x00，0x01，0xAB，0xCD

然后计算校验位：

（~（0x10+0x06+0x00+0x01+0xAB+0xCD）+1）&0xFF ＝ 0x71

添加校验后的有效数据：

0x10，0x06，0x00，0x01，0xAB，0xCD ，0x71

把数组转成16进制字符串：

10060001ABCD71

最后加上帧头帧尾：

:10060001ABCD71\r\n

最后的最后，别忘了通过RS485把这一串字符串发出去！

关于MODBUS-RTU的功能码详细说明，请参见下面的文章：

MODBUS常用功能码_星沉地动的博客

MODBUS-TCP协议

Mon, 12 Dec 2022 09:54:10 +0000

modbus-tcp顾名思义是基于TCP网络连接的MODBUS协议。和RS485总线不同，TCP协议是通过设备的IP地址和端口来寻址。 modbus-tcp的默认端口号是502，设备端作为TCP服务器监听502端口，主机为TCP客户端主动去连接外设。 与RS485一样，主机发起请求，设备返回响应，设备不会主动发送数据。

1个主机可以同时与多个设备建立连接。 1个设备可以同时被多个主机连接。

在协议层使用的包格式是二进制格式：

序号	协议	长度	数据
2字节	2字节	2字节	N字节

序号：标识通信流水号，主机发送时每次加1，设备原样返回。协议：固定为0x00,0x00 长度：表示后续数据的长度（网络序：大端格式）数据：包含设备地址和功能码以及寄存器参数，和RTU格式一样，但不包含校验。

因为TCP本身是可靠通信连接，因此MODBUS-TCP协议层没有添加校验位。

下面是示例：

主机发送：0x00,0x09,0x00,0x00,0x00,0x06,0x01,0x03,0x00,0x01,0x00,0x02 设备返回：0x00,0x09,0x00,0x00,0x00,0x05,0x01,0x03,0x02,0x00,0x00

序号：0x00,0x09 协议：0x00,0x00 长度：0x00,0x06 数据：0x01,0x03,0x00,0x01,0x00,0x02

数据部分的格式和MODBUS-RTU是一样的，但不包含2个字节的CRC16。解析出来就是: 0x01(地址)，0x03（功能码），0x0001（寄存器地址）,0x0002（寄存器数量）

RTU格式请参见：MODBUS常用功能码

设备返回数据时，也是按照上面的格式，带上6字节的帧头再加上N字节的RTU数据。

在此不再赘述。

用python写一个简单的TFTP服务器

Tue, 01 Nov 2022 16:04:39 +0000

用python写一个简单的TFTP服务器，练习python socket用法。暂时只实现文件上传，思路很简单： 1.创建UDP接口； 2.监听69端口； 3.接收UDP数据； 4.解析TFTP协议报文，执行创建文件或写入文件；

#!python
#Simple TFTP Server
#蒋晓岗<kerndev@foxmail.com>

import os
import io
import sys
import time
import socket

def send_ack(s, addr, pid):
	pkt = b"\x00\x04" + pid
	s.sendto(pkt, addr)

def send_err(s, addr, code, reason):
	pkt = b"\x00\x05" + code.to_bytes(2, "big") + reason.encode("utf-8") + b"\x00"
	s.sendto(pkt, addr)
	#print(pkt.hex(" "))

#main
total = 0
processing = False
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(("0.0.0.0",69))
s.settimeout(2)
print("TFTPD start...")
while(True):
	try:
		req = s.recvfrom(1024)
	except Exception as e:
		if(processing):
			processing = False
			fp.close()
			print("\nRecv file failed:", e)
	else:
		req_data = req[0]
		req_addr = req[1]
		#print("recv", len(req_data), "bytes from:", req_addr)
		if(req_data[0:2] == b"\x00\x02"):
			name = req_data[2:].split(b"\x00")[0].decode("utf-8")
			if(processing):
				print("\nRefused new file:", name, ", from:", req_addr)
				send_err(s, req_addr, 0x00, "server busy!")
			else:
				try:
					fp = open(name, "wb+")
				except Exception as e:
					print("Accept new file:", name, ", from:", req_addr, "failed!", e)
					send_err(s, req_addr, 0x03, "disk error!")
				else:
					print("Accept new file:", name, ", from:", req_addr, "OK")
					send_ack(s, req_addr, b"\x00\x00")
					processing = True
					total = 0
		if(req_data[0:2] == b"\x00\x03"):
			if not processing:
				send_err(s, req_addr, 0x04, "invalid session!")
			else:
				pid = req_data[2:4]
				buf = req_data[4:]
				total = total + len(buf)
				fp.write(buf)
				send_ack(s, req_addr, pid)
				print("Recv %d bytes" % total, end="\r")
				if(len(buf) < 512):
					processing = False
					fp.close()
					print("\nRecv file complete, total size:", total, "bytes")

使用Windows自带TFTP进行上传文件的测试。

python改变或不改变函数的输入参数内容

Tue, 01 Nov 2022 13:46:16 +0000

python的函数能像C语言指针一样改变输入参数指向的内容吗？

看一个例子：

#python
#改变或不改变函数的输入参数内容

def change_list(l1, l2):
	l1.append("append")
	l2 = l2 + ["append"]
	print("l1:", l1)
	print("l2:", l2)
	return None

list1 = ["list1"]
list2 = ["list2"]
change_list(list1, list2)
print("----------------------------")
print("list1:", list1)
print("list2:", list2)

运行结果：

从运行结果看，执行函数前后，list1的内容发生了变化，list2的内容没有变。

在函数change_list()里面： l1.append是往列表里追加一个元素，l1列表的内容发生了变化，会导致函数外面的列表内容也跟着一起变。

l2 = l2 + [“append”] 虽然也是在l2列表里追加一个元素，但是等号左边的l2和输入参数l2不是同一个对象，不会导致函数外面的列表发生变化。

可以通过print(id(l1))和print(id(l2))来调试，会发现l2的id前后并不一样。

答案是：python可以像C语言指针一样改变输入对象的内容，但有一定的限定条件。

如果想要改变输入参数的内容，需要参数对象本身有改变自身的能力(函数)，比如list.append()

如果不想改变输入参数的内容，可以使用等号操作符返回一个新的对象，或者使用深拷贝copy.deepcopy(obj)返回一个新的对象。

TELNET协议笔记

Tue, 01 Nov 2022 11:41:42 +0000

TELNET是基于TCP协议的应用层协议，服务器默认监听23端口。客户端与服务器建立连接后有一个协商过程，这个过程是可选的。协商完成后，就是数据透传了，服务器发什么客户端就显示什么内容。

有两个细节通过协商完成：

1.回显

客户端回显：客户端发送数据时自己在屏幕上把发送的内容显示出来；服务器回显：客户端发送数据时屏幕不显示，由服务器把数据发回来，客户端再显示内容。

2.行模式

开启行模式：客户端在收到回车键后再发送整行内容；关闭行模式：客户端每按一个键就发送一次按键内容；

之所以提到这2个细节是因为Windows自带的telnet客户端和SecureCRT的默认行为不一样。

Windows Telnet：连接时没有主动发起协商，默认客户端回显，回车按键发送CRLF。

SecureCRT：连接时主动发起协商，默认客户端回显，默认开启行模式，回车按键发送CR\0。

SecureCRT回车内容可通过参数配置： Options/Session Options/Terminal/Emulation/Modes/New line mode

默认不勾选，勾选New line mode后回车发送CRLF Options/Session Options/Telnet/Server requires bare CR

默认不勾选，勾选后CR后面不带0x00

行为一致协商：只要服务器在连接时发送： FF FB 01，就可以使两个客户端的行为变成一致。 FF FB 01表示服务器要开启回显，SecureCRT关闭回显的同时也会关闭行模式。这样每一次按键，服务器都能收到1次数据，客户端都不会回显。

扩展内容：命令字： 0xFF:IAC 选项协商字节 0xF0:SE 子选项结束 0xFA:SB 子选项开始 0xFB:WILL 发送方想激活选项，接收方回复DO(同意)/DONT(不同意) 0xFC:WONT 发送方想禁止选项，接收方必须同意，回复DONT 0xFD:DO 发送方想让对方激活选项，接收方回复WILL(同意)/WONT(不同意) 0xFE:DONT 发送方想让对方禁止选项，接收方必须同意，回复WONT

选项字： 0x01: 回显 0x03: 抑制继续进行 0x18: 终端类型 0x1F: 窗口大小 0x20: 终端速率 0x21: 远程流量控制 0x22: 行模式 0x24: 环境变量

KEIL/MDK中的标准C库函数printf和malloc实现线程安全

Wed, 17 Aug 2022 14:22:38 +0000

在ARM嵌入式开发中，编译器提供的C库函数有 一部分 不是线程安全的。如果项目中运行了第三方RTOS，在调用标准C库函数时就要关心它们是不是线程安全的。

比如printf函数，它是可重入的函数，但是在多线程环境下打印的内容可能会交叉乱序。当然这种问题还不算严重。但如果调用库函数malloc，这个函数在RTOS环境下多线程调用则会引发堆数据结构异常。

那么有没有办法让C库标准函数实现线程安全呢？

经过查阅文档，在KEIL/MDK中确实存在这么一种方法，可以实现malloc线程安全。

在KEIL/MDK的标准库中提供了一组可重载的互斥锁函数，我们可以自行实现这一组函数，来保证C库函数线程安全。

函数原型和参考实现代码如下：

//创建互斥锁，成功返回1，失败返回0
int _mutex_initialize(mutex *m)
{
    *m = mutex_create(); /* 调用RTOS提供的函数，创建锁 */
    return 1;
}

//获取互斥锁(加锁操作)
void _mutex_acquire(mutex *m)
{
    mutex_lock(*m); /* 调用RTOS提供的函数，加锁 */
}

//释放互斥锁(解锁操作)
void _mutex_release(mutex *m)
{
    mutex_unlock(*m); /* 调用RTOS提供的函数，解锁 */
}

//删除互斥锁
void _mutex_free(mutex *m)
{
    mutex_delete(*m); /* 调用RTOS提供的函数，删除锁 */
}

需要注意的是，重载以上互斥锁函数后，要确保调用C库函数的时机一定要晚于RTOS的初始化。

KEIL官方参考资料:

ARM编译器：重载互斥锁实现C库函数线程安全

ARM编译器：线程安全的C标准库函数

ARM编译器：线程不安全的C标准库函数

一种简单通用的获取函数栈空间大小的方法

Wed, 27 Jul 2022 13:33:42 +0000

有些时候我们需要评估某个函数所使用的栈空间大小，比如创建线程的时候，我们需要估算该线程函数所需的栈空间，分配合适的线程栈。

本文介绍一种简单的方法，来获取某个函数所占用的栈空间大小。

原理：

针对递减栈内存模型，调用函数时，栈指针会往下移动，移动的距离取决于该函数的局部变量和调用子函数，也就是该函数所使用的栈空间，在函数返回时，栈指针又会恢复到调用前的位置。

根据这一特性，我们可以在调用函数前把栈底部的内存用一个特定值来填充，调用结束后检查栈底部的值是否发生变化，搜索到最后1个发生变化的地址就是该函数所使用的栈底。用当前栈指针减去栈底指针就能算出该函数实际使用的栈空间大小。

实施：

废话不多说，直接上测试代码：

//用0xAA填充栈底512字节
void stack_test_begin(void)
{
	register int i;
	unsigned char mem[512];
	for(i = 0; i < 512; i++)
	{
		mem[i] = 0xAA;
	}
}

//检查栈底，返回栈大小
int stack_test_end(void)
{
	register int i;
	unsigned char mem[512];
	for(i = 0; i < 512; i++)
	{
		if(mem[i] != 0xAA)
		{
			return 512 - i;
		}
	}
	return 0;
}

//被测试函数, 此函数理论占用栈空间为128字节
void stack_use_128(void)
{
	register int i;
	char mem[128];
	for(i=0; i<128; i++)
	{
		mem[i] = 0;
	}
}

//测试
void main(void)
{
    int stack_size;
	stack_test_begin();
	stack_use_128();
    stack_size = stack_test_end();
	printf("stack: %d\n", stack_size);
}

代码解读：

面对JFlashLite修不好的BUG若有所思

Fri, 08 Jul 2022 18:04:08 +0000

JLink做为最常用的ARM调试工具，其配套上位机软件的版本更新频率几乎是一月N更，甚至有隔天就更新，这更新频率连一直刷版本号的chrome都怕是要自愧不如。

更新日志在这里，有兴趣的可以看一看。

JLink更新日志

其中JFlashLite是一个比较精简的烧录工具，比完整版JFlash的操作简单明了。有些时候只是为了下载HEX文件，用它是很合适的选择。

但是这个工具从JLink 5.0版本发布，最目前最新版本V7.66，已经有7年历史了。就这么一个几百KB的小小小小工具，却还BUG百出。

不得不让我发生思考：这是什么样的软件管理？ Segger的上位机软件开发团队可能存在很大的问题？一方面开发人员的流动性可能很大，一套代码频繁换人就可能出现解决1个BUG，产生10个BUG。另一方面还暴露出软件测试非常匮乏，不经过认真测试就直接发版了，有些BUG稍微测试一下就能发现的却流到了正式版本。最有可能的情况是这个小工具本身对于JLink来说并不重要，让那些没经验的新人来写代码。

我连续下载了N个历史版本来对比，想找一个相对稳定好用的版本，发现每个版本都是BUG。

简单总结下JFlashLite这个软件的历史：

V5.00 - V6.12j： BUG：日志输出窗口会乱序输出（多线程输出没有做好同步）。缺点：没有记录最后选择的MCU型号，每次要重新选芯片。缺点：MCU选择对话框只能按厂商过滤，不能按型号过滤，找芯片很麻烦。优点：支持中文路径，窗口大小可以调整。

V6.14: 优点：增加了记住最后选择的MCU型号的功能。

V6.30b: 优点：增加了按MCU型号搜索过滤的功能。缺点：不能调整窗口大小，窗口太小文件路径会显示不全。 新增BUG ：文件选择对话框换了风格（全英文），且不能选择本地磁盘以外的路径。 新增BUG ：无法下载中文路径的HEX文件（之前的版本支持中文）。

V6.30c: 解决了日志输出窗口会乱序输出的问题。

V6.32: 这个版本终于发现文件选择对话框的问题了，又改回原来的文件选择方式。

V6.48: 默认的烧录地址从0变成了MCU的FLASH起始地址。

V6.60: 这个版本文件路径框变成只读（之前可写，但改写也没用）。 新增BUG ：日志输出大部分内容都不会换行，全挤在一行。

V6.82: 解决中文路径的文件无法下载的问题； 新增BUG ：选择中文路径后无法选择其它中文路径的文件；

V6.94b: 解决了日志输出不换行的问题。

V6.94c - V7.66g: BUG依旧，中文路径只能选1次，但可以选英文路径的文件。

这个小工具，估计代码量也就2K行左右，随便有点QT基础都能写出来。实在不应该这么多问题。

MODBUS常用功能码

Wed, 15 Jun 2022 11:14:54 +0000

1 简述

Modbus寄存器分为四种，如表1.1所示：

表1.1 寄存器分类

寄存器种类	数据类型	访问类型	功能码	PLC地址	寄存器地址
线圈寄存器	位	读写	01H 05H 0FH	00001-09999	0000H-FFFFH
离散输入寄存器	位	只读	02H	10001-19999	0000H-FFFFH
输入寄存器	字	只读	04H	30001-39999	0000H-FFFFH
保持寄存器	字	读写	03H 06H 10H	40001-49999	0000H-FFFFH

2 常用功能码

Modbus中常用的功能码有8个，可以分为位操作和字操作两类，如表2.1所示：

表2.1 常用功能码

功能码	描述	PLC地址	寄存器地址	位/字操作	操作数量
01H	读线圈寄存器	00001-09999	0000H-FFFFH	位操作	单个或多个
02H	读离散输入寄存器	10001-19999	0000H-FFFFH	位操作	单个或多个
03H	读保持寄存器	40001-49999	0000H-FFFFH	字操作	单个或多个
04H	读输入寄存器	30001-39999	0000H-FFFFH	字操作	单个或多个
05H	写单个线圈寄存器	00001-09999	0000H-FFFFH	位操作	单个
06H	写单个保持寄存器	40001-49999	0000H-FFFFH	字操作	单个
0FH	写多个线圈寄存器	00001-09999	0000H-FFFFH	位操作	多个
10H	写多个保持寄存器	40001-49999	0000H-FFFFH	字操作	多个

3 读线圈寄存器(01H)

功能码01H读取Modbus从机中线圈寄存器的状态，可以是单个寄存器，或者多个连续的寄存器。

TFTP文件传输协议

Wed, 15 Jun 2022 10:58:08 +0000

TFTP是一个简单的文件传输协议，默认使用UDP，服务器开放69端口。

关于协议的细节网上可以找到，在此不再赘述。

本文用一个简单的通信实例来分析通信协议。

Windows 系统自带TFTP客户端，服务器可以下载tftp32，下面是下载连接。phjounin / tftpd64 / Downloads — Bitbucket

打开cmd.exe输入以下命令：

tftp -i 192.168.1.100 PUT D:\123.txt 123.bin

这条命令会把本地的D:\123.txt文件上传到服务器，在服务器生成的文件名为 123.bin。

并没有要求上传的文件名必须一样，可以在上传时对文件改名。

我们用wireshark进行抓包，看看它们是怎么通信的。

下面是所有的通信数据，文件内容用XX替换了。

客户端发送：
00 02 31 32 33 2e 62 69 6e 00 6f 63 74 65 74 00

服务器响应：
00 04 00 00

客户端发送：
00 03 00 01 XX ... XX (文件数据长度512字节)

服务器响应：
00 04 00 01

客户端发送：
00 03 00 02 XX ... XX（文件数据长度182字节）

服务器响应：
00 04 00 02

到此传输完成.
这个测试文件总长度694字节，第1次传输512，第2次传输182，就传输完成了。

对每一条数据进行解释：第1次通信是建立握手，告诉服务器准备上传文件，并告知文件名和传输方式。

代码缩进对齐用空格还是制表符？

Fri, 22 Apr 2022 18:05:29 +0000

代码缩进对齐用空格还是制表符？这是一个一直都存在争议的问题，C、C++语言没有要求。而python作为一门新兴语言，它规定了必须保持一致的缩进，不能混用空格和制表进行缩进。

我的看法

首先：空格和制表符的特点 空格是可显示的空白字符，固定占用1个字符的宽度。制表符是控制字符，占用的宽度与编辑器的设置相关，占用宽度不固定。

为什么有的程序员很歧视制表符，就是因为用制表符做代码对齐的时候，在不同的编辑器下面会得到不同的对齐效果。

比如下面的代码：使用制表符，制表宽度为4的时候代码是对齐的。

但是如果编辑器的制表宽度为8的时候，代码是不对齐了。

其次：代码缩进和对齐是两个不同的概念 缩进: 针对行首，向右缩进，让代码有层次感；对齐: 行首以外的地方，让代码纵向对齐；

python要求代码必须缩进，但是并没有要求一定要对齐。 python没有花括号，只能用缩进的方式来判断代码层次。缩进如果用空格，其建议值是4个空格，或者直接采用制表符缩进。

void main(int argc, char **argv)
{ /* 缩进：花括号顶格，下面的代码缩进1级 */
    int   a;
    short ab;
    char  abc; /* 对齐：变量名左对齐 */
    for(a = 0; a < 100; a++)
    {   /* 缩进：花括号下面的代码缩进2级 */
        ab  = a + 10; /* 对齐：操作符中间对齐 */
        abc = a * 10;
    }
}

结论：到底用空格还是制表符？

这个问题，缩进和对齐我们要分开来讨论对于代码缩进，我推荐用 制表符。 对于代码对齐，我推荐用 空格。

代码对齐不能用制表符，而必须使用空格，因为不同的编辑器制表符宽度可能不一样，不能保证代码严格对齐，而空格没有这个问题。

原因： 1.制表符输入方便，空格需要多敲几次，有可能出现空格数量不是4的倍数的情况；

有人会说，现在的编辑器，都可以自动把TAB键变为4个空格啊？是的，输入TAB变4个空格没毛病，但是回退就不行啊。对于制表符缩进，只要按一次回退就可以，而空格方式要按4次回退键！ 我见过一段代码被多人频繁修改后，采用4个空格缩进，在第2层for循环时，本来应该是缩进12个空格，但最后变成了11个空格。

2.修改编辑器设置可以实现不同缩进宽度的视觉效果； 3.制表符生成的源码文件要比空格体积小，因为制表符只占1个字节，而4个空格占4个字节；

源码文件变小了，理论上还可以略微提高编译速度；

使用空驱动消除设备管理器里面的未知设备

Tue, 12 Apr 2022 09:27:38 +0000

前言

全新重装Windows系统之后，安装完声卡，网卡，显卡，USB设备等驱动之后。还是会在设备管理器里面看到一些未知的PCI设备。这些PCI设备大多数是主板芯片组的一些特殊控制设备， 一般情况下：不给它们安装驱动，也不会影响系统使用。 但是每次打开设备管理器，看到一堆感叹号，还是很不舒服。正常情况都是去下载对应主板的chipset驱动，可以解决。

今天介绍一种通用的方法，制作空驱动，消除未知设备。

1.找到这个设备

如下图的：PCI 简单通讯控制器

2.找到设备的硬件ID

一般只要记住PCI\VEN_XXXX&DEV_XXXX就行。

3.制作空的驱动安装文件

按照下面的模板，修改对应的设备ID就可以。

最后两行，VENDOR和PRODUCT的名字也是可以随便修改的。

另存为xxxx.inf

[Version]
Signature=$WINDOWS NT$
Class=System
ClassGUID={4D36E97D-E325-11CE-BFC1-08002BE10318}
Provider=%VENDOR%
DriverVer=01/01/1970, 1.0.0.0
PnpLockDown=1

[SourceDisksNames]

[SourceDisksFiles]

[ControlFlags]
ExcludeFromSelect=*

[Manufacturer]
%VENDOR%=VENDOR,NTx86,NTamd64

[VENDOR.NTx86]
%PRODUCT%=Needs_NO_DRV,PCI\VEN_8086&DEV_A360

[VENDOR.NTamd64]
%PRODUCT%=Needs_NO_DRV,PCI\VEN_8086&DEV_A360

[Needs_NO_DRV]
Include=machine.inf
Needs=NO_DRV

[Needs_NO_DRV.Services]
Include=machine.inf
Needs=NO_DRV.Services

[Strings]
VENDOR="INTEL"
PRODUCT="PCI_8086_A360"

4. 手动安装驱动

依次点击：更新驱动程序->浏览->选中xxxx.inf文件的路径->下一步。

注意：我们制作的空inf驱动，没有数字签名，可能会被系统拒绝。如何给驱动签名，又是另外一个问题了。

5.安装完成

再次查看设备管理器，未知设备消失。它被列入了系统设备。

调用约定不一致引发“error LNK2019: 无法解析的外部符号“

Thu, 24 Mar 2022 11:34:06 +0000

前言

Visual Studio 编译选项有3种调用约定：__cdecl、__stdcall、__fastcall

__cdecl是默认的调用约定，也是C语言的标准调用约定。 __stdcall是Windows API使用的调用约定。 __fastcall用得比较少。

三种调用约定的细节，在网上有更详细的说明，这里就不解释了。参考官方文档：https://docs.microsoft.com/zh-cn/cpp/cpp/argument-passing-and-naming-conventions?view=msvc-170

问题还原：

现在有这样一个VC++工程，有3个源文件：

main.c api.h api.c

main.c的源码如下：

#include "api.h"
int main(void)
{
    int ret;
	ret = api_call(0);
	return ret;
}

api.h的源码如下：

#pragma once

int api_call(int a);

api.c的源码如下：

#include "api.h"
int api_call(int a)
{
	int b;
	b = a + 1;
	return b;
}

这是一个非常简单的演示程序，在main函数调用api.c提供的接口。正常情况下编译也不会有任何问题。

问题在于有一次不小心修改了编译选项：在VS工程目录上点击api.c右键 -> 属性 -> C/C++ -> 高级 -> 调用约定 -> 选择__stdcall 并且保存后忘记改回去，过了很久很久之后，重新打开这个工程，编译报错了：

无法解析的外部符号 “int __cdecl api_call(int)” (?api_call@@YAHH@Z)，该符号在函数 _main 中被引用

ANSI终端常用控制字符

Tue, 22 Mar 2022 18:07:33 +0000

以前收藏了一篇关于ANSI终端的介绍[http://www.termsys.demon.co.uk/vtansi.htm] 最近发现这个链接已经打不开了！于是将相关的内容记录到博客当作备份。这里记录的是常用的控制字符，还有一些不常用的就没有列出来了。

控制字符	功能
0x08	回退(\b)，光标向左移动1格
0x0A	换行(\n)，光标向下移动1行
0x0D	回车(\r)，光标向左移动到行首
0x1B,0x5B,0x41	光标向上移动1格
0x1B,0x5B,0x42	光标向下移动1格
0x1B,0x5B,0x43	光标向右移动1格
0x1B,0x5B,0x44	光标向左移动1格
0x1B,0x5B,0x4B	清除光标右边的所有文字
0x1B,0x5B,0x31,0x4B	清除光标左边的所有文字
0x1B,0x5B,0x32,0x4B	清除光标行的所有文字
0x1B,0x5B,0x30,0x6D	设置文字显示为默认方式
0x1B,0x5B,0x31,0x6D	设置文字加高亮
0x1B,0x5B,0x34,0x6D	设置文字加下划线
0x1B,0x5B,0x37,0x6D	设置文字反色显示
0x1B,0x5B,0x33,0x3N,0x6D	设置文字颜色（N:0-7）
0x1B,0x5B,0x34,0x3N,0x6D	设置文字背景色(N:0-7)

N：颜色定义 0：黑色 1：红色 2：绿色 3：黄色 4：蓝色 5：紫色 6：青色 7：白色

全志F1C100S的BROM研究

Fri, 04 Mar 2022 00:33:33 +0000

全志f1c100s是个性价比很高的芯片，但是对一般人不太友好的是它的资料开放的太少了。网上找不到完整版的用户手册，只能从有限的手册文档和参考代码旁敲侧击，反向猜测。关于它的BROM网上的手册内容很少。

手册上只有短短3句话：

具体怎么个启动流程，完全没有描述。

但是从网上的代码和开发板资料来看，它启动是按照顺序自动选择。

我用的开发板只有SPI FLASH，它是先从SPI NOR FLASH启动，无法读到有效的SPL，则进入USB下载模式。

而进入USB模式的按键，其实就是把SPI的片选拉低，让它无法读FLASH内的数据，从而进入USB模式。

USB下载模式官方提供一个sunxi-fel.exe的工具，很方便，它支持下载image到RAM，同时也支持直接下载到SPI-FLASH，还能读回数据。

如何判断SPL的有效性？

文档没有描述，也是通过参考代码，代到线索。

启动文件是这样写的，生成的BIN头部必须包含下面的内容。

;/* Boot head information for BROM booting */
BROM_BHI        B       Reset_Handler
				DCB     "eGON.BT0"
				DCD     0, 0x4000
				DCB     'S', 'P', 'L', 2
				DCD     0, 0
				DCD     0, 0, 0, 0, 0, 0, 0, 0
				DCD     0, 0, 0, 0, 0, 0, 0, 0

编译生成的SPL.bin内容如下格式：

除了编译生成的文件头信息外，还需要后期修改如下内容：

偏移000C：此SPL.bin的校验，用mksunxi.exe生成。偏移0010：此SPL.bin的长度，必须256字节对齐。

SPL是在哪里运行的？

我们怎么确定SPL的运行环境？文档也是没有任何描述。

下面文档的内存映射表：

BROM在0地址有32KB，内部SRAM在0x10000有40KB。 那事实真的如此吗？

解决SecureCRT串口日志突然出现乱码的问题

Mon, 10 Jan 2022 17:28:11 +0000

用SecureCRT这个软件来查看串口日志很多年了，很早就发现了这个问题。但一直没有去追究原因，今天终于抽出时间来研究一下这个问题。

问题现象： 用SecureCRT打印串口日志，一开始正常，突然就变成乱码了。必须要关闭串口再重新打开才能恢复。

问题原因： SecureCRT默认的终端是VT100。这个终端收到0x0E会进入这种乱码模式，收到0x0F退出乱码模式。参考链接： secureCRT 串口显示乱码–必须要重启串口才能恢复-嵌入式-CSDN问答

解决办法： 修改SecureCRT的终端类型为ANSI或者Dumb。

这个遗留多年的问题，终于找到解决办法了。

Cortex-M处理器中断向量表

Fri, 31 Dec 2021 18:06:25 +0000

这是Cortex-M3手册里面截取出来的中断向量表：

系统复位后中断向量表始终是在0x00000000地址。系统启动后可以对中断向量表进行重定向: SCB->VTOR ＝ vector_addr;

中断向量表可以看做一个uint32_t类型的数组，数组长度取决于芯片厂商定义多少个中断。从IRQ0开始属于芯片厂商自定义的中断。

Cortex-M0最多32个中断 Cortex-M3/M4/M7最多240个中断

系统上电时： 第1个成员用于初始化SP寄存器第2个成员用于初始化PC寄存器其余成员都指向对应的中断处理程序的地址。

当发生中断的时候，MCU从中断向量表中找到该中断服务程序的地址，跳转过去。跳转之前，MCU会自动完成部分寄存器的入栈，入栈顺序如下图所示。中断服务程序返回时，MCU自动完成这部分寄存器的出栈。

关于中断优先级：

中断最多可以用8bit来控制优先级，且数值越小优先级越高有三个特殊值：HardFault = -1、NMI=-2、RESET=-3 这8个bit又可以分成2组：抢占优先级和子优先级。下图是优先级的分组方式：

抢占优先级高的，可以打断正在执行的低优先级中断，先执行高优先级中断。抢占优先级相同的情况下，子优先级之间不会发生抢占。

当多个中断同时发生时，按照以下顺序比较优先级： 抢占优先级 -> 子优先级 -> 中断号

中断向量表实例：

中断向量表是在start.s里面定义好的，编译器会把它放到BIN文件的起始位置。随便打开一个编译出来的BIN文件进行查看：

因为Cortex-M一般是小端格式，所以每4个字节要倒过来。前4个字节就是0x1000EA68，它表示上电后的SP值。接下来4个字节是0x00000101，它表示ResetHandler，它表示上电后的PC值。 PC＝0x00000101，所对应的第一条指令就是0x5088F64E。

备注： PC最低位为1表示是Thumb模式，并不是真实的地址偏移。指令0x5088F64E的第[15:11]位为11110B，表示这是一条32位Thumb指令。

从这个文件我们还能反向推断出其它的信息： ROM起始地址是0x00000000 RAM起始地址(可能)是0x10000000 目标MCU肯定不是Cortex-M0 这段代码可能使用了RTOS

Cortex-M核心寄存器

Fri, 31 Dec 2021 17:57:57 +0000

下面是Cortex-M3手册截图，核心寄存器一共有21个：

Cortex-M0没有FAULTMASK Cortex-M0没有BASEPRI Cortex-M3/M4/M7寄存器相同

R0–R12：通用寄存器

在AAPCS(过程调用标准)中R0-R3用于传递函数参数，如果参数超过4个则将参数压栈传递。 R0用于传递函数返回值。 R4-R11则用于临时变量

R13(SP)：栈指针

SP背后有2个物理寄存器MSP和PSP，上电默认MSP。可以用CONTROL寄存器来选择使用MSP或PSP。 Cortex-M使用的是满递减栈。

R14(LR)：链接寄存器

LR在调用函数时保存函数的返回地址。在中断服务程序中用作EXC_RETURN，用于确定中断结束后恢复状态。

R15(PC)：程序计数器

PC保存的是当前运行指令的地址，直接修改PC可以改变运行指令。 PC的最低位并不是地址，而是Thumb状态位，会被写到到EPSR的T位，读回的总是0。

PSR：程序状态寄存器

PSR寄存器实际上是由APSR、IPSR、EPSR合并而来，所以一般用xPSR表示。

NZCVQ分别表示负数、零、进位或借位、溢出、DSP溢出或饱和标志位。 ISR_NUMBER表示当前的运行的是哪个中断，0表示在主线程模式。 ICI 可中断后继续运行的指令状态，IT指示IT指令的状态，T指示Thumb指令模式。

CONTROL：控制寄存器

FPCA指示当前FPU状态，1=FPU使用中，0=FPU未使用 SPSEL指示当前SP用的是哪个，1=PSP，0=MSP nPRIV指示当前特权等级，1=非特权模式，0=特权模式

BASEPRI：起始优先级寄存器

中断优先级的数值小于BASEPRI才能响应，优先级数值越低，优先级越高 BASEPRI=0x00时此寄存器无效

PRIMASK：优先级屏蔽寄存器

PRIMASK置为1时，除了NMI和HardFault以外，其它中断都被屏蔽。通常用它来控制系统的全局总中断，写1相当于关闭中断，清0相当于打开中断。

FAULTMASK：错误屏蔽寄存器

FAULTMASK置1后可以屏蔽HardFault，只有NMI中断能正常响应。在任何中断服务程序退出时会自动清0。

Cortex-M系列处理器对比

Fri, 31 Dec 2021 16:26:40 +0000

ARM发展至今，已经设计了9代处理器构架，每一代架构又设计了不同的处理器核心。下表并没有把全部的处理器核心列举出来，只做为参考。

从第6代开始，ARM11以后的处理器命名方式改为3个系列：

Cortex-A：面向性能密集型系统的应用处理器内核 Cortex-R：面向实时应用的高性能内核 Cortex-M：面向各类嵌入式应用的微控制器内核

目前市面上主流的微控制器主要还是Cortex-M0，M3，M4和M7。 Cortex-M33,M35等新一代微控制器内核应该还要几年才会普及开来。

目前所有Cortex-M内核的ARM官方提供的功能对比如下：

官方提供的表内容很多，但是有一些参数并没有出现在这个表里面。因此我自己整理了一个我们平常比较关心的几个参数：

	架构	DMIPS	FPU	硬件除法	中断数	中断优先级
Cortex-M0	ARMv6-M	0.87/MHz	无	无	32	4
Cortex-M0+	ARMv6-M	0.95/MHz	无	无	32	4
Cortex-M3	ARMv7-M	1.25/MHz	无	有	240	256
Cortex-M4	ARMv7-M	1.25/MHz	单精度	有	240	256
Cortex-M7	ARMv7-M	2.14/MHz	双精度	有	240	256

Cortex-M3和Cortex-M4基本上只有FPU的区别，其实M4还多了一些DSP扩展指令。 Cortex-M7性能爆表，DMIPS跑分已经超过了Cortex-A8。

虽然它们之间存在这么多差异，但是向上兼容性却做的很好。 Cortex-M0向上兼容M3，M3向上兼容M4，M4向上兼容M7。这种兼容是二进制级别的兼容，也就是说用Cortex-M0编译出来的代码，可以直接在M3运行。只不过由于指令集的原因，不能发挥M3全部的性能。

为什么这么说呢？ 因为Cortex-M0只支持Thumb基础指令集，大量16位指令，和少数几条32位指令。其中大部分16位指令只能访问R0 - R7寄存器，比如LDR/STR。要访问R8－R12只能使用MOV指令。

而Cortex-M3则支持Thumb2扩展指令，包含了大量的32位指令，运行效率可以极大提升。比如LDRD指令，可以一次性读取64位数据到2个寄存器。

此外由于架构的原因，Cortex-M0不支持非4字节对齐的32位整数访问，而Cortex-M3则可以。

聊聊MCU的困惑

Fri, 24 Dec 2021 18:11:51 +0000

不知道有没有人心中有这种困惑：

什么是MCU？ MCU和MPU有什么区别？ MCU和SOC有什么关系？ MCU和单片机有什么关系？

Ambiq Apollo3使用内建SBL进行固件升级

Thu, 16 Dec 2021 14:23:17 +0000

Apollo3系列MCU出厂时内置了一段代码，官方名叫：SBL(Secure BootLoader) 这段代码在片上FLASH的0x0000地址，占用空间48KB。这就是为什么我们在KEIL里面看到的IROM起始地址是0xC000。这段代码实现了开机通过UART、I2C、SPI下载用户程序的功能，同时还实现了IAP固件升级功能。

今天研究的就是它的IAP固件升级功能。在阅读了大量文档和SDK代码之后，工作过程大概是这样的：

1.在MCU的内部FLASH规划出至少3个区域：
        固件区: 正常跑的固件程序，起始地址0xC000
        升级区: 新固件下载到这里。
        描述区: 记录新固件在FLASH的地址，只需要1个扇区：8KB
2.准备好编译出来的固件文件firmware
3.使用create_cust_image_blob.py脚本对firmware进行处理，生成新文件image
4.把image下载到规划的升级区
5.把升级区的地址写到描述区
6.把描述区的地址写到OTACTRL_OTAPOINTER寄存器，并把OTA标志位写1
7.软件重启MCU后，SBL会根据OTACTRL_OTAPOINTER的信息进行固件升级。

知道大概流程之后就来看一看实现的细节：

1.MCUCTRL_OTAPOINTER寄存器 贴个文档里的图：

OTAPOINTER[31:2] = 描述区的地址，此地址必须为FLASH地址8KB对齐，忽略低2位 OTAPOINTER[1] = 1，表示SBL升级，下次重启后会升级SBL自身 OTAPOINTER[0] = 1，表示OTA有效，下次重启后会触发升级

2.升级描述区 升级描述区占用1个FLASH扇区，1个扇区＝8KB 贴个文档里的图：

描述区是一个32bit为单位的数组，每个单位是一个描述符，如果有多个描述符，就是可以一次性升级多个文件，最后一个描述符为0xFFFFFFFF表示结束。一般情况下固件升级我们只需要一个文件，所以只需要填写一个描述符就够了。描述符BIT[31:2]表示升级文件所在的地址. 描述符BIT[1]表示升级结果，1=失败，0=成功描述符BIT[0]表示升级状态，1=挂起，0=完成升级之前，BIT1和BIT0都要置1，这样SBL才会处理这条升级描述。

3.制作升级文件 编译器生成的binary文件是不能直接用于升级的，SBL只能识别包含特定文件头的文件。这个文件的格式如文档中描述，下图是NonSecure Main格式：

从图中可以看出来，头件头部多了很多字段，还支持数据加密，一般情况下使用这种格式已经完全满足项目需要了。 Secure Main的文件头更复杂一些，已经没有兴趣再看下去了。官方SDK中已经提供了一个python脚本来制作这种文件。

文件路径：/sdk/tools/apollo3_scripts/create_cust_image_blob.py
调用参数：--bin input.bin -o output.bin --version 0xEFFF --magic-num 0xcb --load-address 0xc000
--bin指定编译器生成的原始bin文件
-o指定输出的新文件名
--load-address指定升级文件的目标地址（编译器配置的IROM起始地址）
--magic-num指定文件类型，0xcb表示主程序固件
--version这个参数为可选参数，可以指定固件版本，范围0-0x7FFF，保存在W29的低15bit，

4.代码实现 官方SDK中提供了一些有用的代码来实现我们的固件升级。下面两个是实现内部FLASH的擦除与编程的接口，下载新固件的时候会用到。

//擦除，以8KB为单位进行擦除
int am_hal_flash_page_erase(uint32_t ui32ProgramKey, uint32_t ui32FlashInst, uint32_t ui32PageNum);

//写入，以4字节为单位写数据
int am_hal_flash_program_main(uint32_t ui32ProgramKey, uint32_t *pSrc, uint32_t *pDst, uint32_t  NumberOfWords);

下面两个是实现添加OTA描述符的接口，下载完新固件之后，需要用到

蓝牙HID键盘码表

Thu, 23 Sep 2021 09:28:17 +0000

键名	键值
A	0x04
B	0x05
C	0x06
D	0x07
E	0x08
F	0x09
G	0x0A
H	0x0B
I	0x0C
J	0x0D
K	0x0E
L	0x0F
M	0x10
N	0x11
O	0x12
P	0x13
Q	0x14
R	0x15
S	0x16
T	0x17
U	0x18
V	0x19
W	0x1A
X	0x1B
Y	0x1C
Z	0x1D
1	0x1E
2	0x1F
3	0x20
4	0x21
5	0x22
6	0x23
7	0x24
8	0x25
9	0x26
0	0x27
Enter	0x28
Esc	0x29
Backspace	0x2A
Tab	0x2B
Space	0x2C
-	0x2D
=	0x2E
[	0x2F
]	0x30
\	0x31
;	0x33
‘	0x34
`	0x35
,	0x36
.	0x37
/	0x38
CapsLock	0x39
F1	0x3A
F2	0x3B
F3	0x3C
F4	0x3D
F5	0x3E
F6	0x3F
F7	0x40
F8	0x41
F9	0x42
F10	0x43
F11	0x44
F12	0x45
PrintScreen	0x46
ScrollLock	0x47
Pause	0x48
Insert	0x49
Home	0x4A
PageUp	0x4B
Del	0x4C
Delete	0x4C
End	0x4D
PageDown	0x4E
→	0x4F
←	0x50
↓	0x51
↑	0x52
NumLock	0x53
Num/	0x54
Num*	0x55
Num-	0x56
Num+	0x57
NumEnter	0x58
Num1	0x59
Num2	0x5A
Num3	0x5B
Num4	0x5C
Num5	0x5D
Num6	0x5E
Num7	0x5F
Num8	0x60
Num9	0x61
Num0	0x62
Num.	0x63
Menu	0x76
Prev	0x80
Next	0x81
Stop	0x82
Play&Pause	0x83
Mute	0x84
VolUp	0x85
VolDown	0x86
Ctrl	0xE0
Shift	0xE1
Alt	0xE2
Win	0xE3
Ctrl	0xE4
Shift	0xE5
AltGr	0xE6
Win	0xE7

[蓝牙]nRF52840+S340协议栈无法被iPhone连接的问题

Mon, 23 Aug 2021 15:47:36 +0000

从官方SDK例程中，删掉了peer_manger模块，蓝牙设备不支持配对。导致iPhone上面的测试APP无法正常连接到设备。通过分析日志，发现手机与设备的connect过程其实是成功了。只不过connect之后，手机端又发起了一些其它未知请求，没有被设备端处理，导致手机端又主动断开了连接，然后报错。查阅资料后，解决方案如下：

在on_ble_evt函数中添加以下代码：

static void on_ble_evt(ble_evt_t const * p_ble_evt)
{
		......
		case BLE_GAP_EVT_SEC_INFO_REQUEST:
			sd_ble_gap_sec_info_reply(p_ble_evt->evt.gatts_evt.conn_handle, NULL, NULL, NULL);
			break;
		case BLE_GATTS_EVT_SYS_ATTR_MISSING:
			sd_ble_gatts_sys_attr_set(p_ble_evt->evt.gatts_evt.conn_handle, NULL, 0, 0);
			break;
		default:
			break;
}

重新测试，问题解决。

HC32F460外设中断用法

Wed, 07 Jul 2021 16:25:33 +0000

华大HC32F460的外设中断和STM32相比也是非常的个性！！！先来看看HC32F460的启动文件startup.s，如下图所示：

从这个文件可以看出来，它定义的中断向量表里，对中断名有只一个编号，没有写明具体是哪个外设的中断。

这就非常有意思，因为HC32F460的外设中断的中断号是可以“任意”编程的，不过这个“任意”也并不是全部128个中断都可以随便选择，也有一定的小规则，查看手册INTC章节，有如下所示的表格：

比如GPIO中断，只能选择0-37或者128。

下面就来看看怎么把外设中断和中断号关联起来：这里以UART１外设为例。首先还是看手册的中断请求表，找到UART1，如下图，UART这个外设有5个中断事件。

我们知道，常规的MCU外设如STM32一样，通常是一个UART外设的所有中断请求都是共用同一个中断号，然后在该中断服务程序里面判断外设的标志位，得到中断源，并做出在相应和处理。

但是HC32F460就完全不一样了，UART外设里的每个中断标志位，都是独立请求中断，必须单独给分配中断号，这样一来，一个UART就可以有5个中断服务程序了，编程其实更麻烦了。

比如上面的USART1_REI表示串口接收错误，可以分配0-31/80-85/136这些中断号，如果要给它分配的中断号是80，那么需要往寄存器INT_SEL80里写入278，其中278就是USART1_REI的中断事件序号。当UART１发生接收错误时，就会触发278号中断事件，该事件绑定了80号中断请求，就会执行IRQ080_Handler中断函数，我们在这个函数里面去处理对应的数据就可以了。

再比如USART1_RI表示接收到数据中断，我们给它分配中断号81，那么就要往INT_SEL81写入279，然后在IRQ081_Handler中断函数里面去处理接收数据。

上面是HC32F460的中断配置寄存器用法，华大提供了一个驱动库，里面有一个hc32f460_interrupts.c文件，实现了中断管理，但是很坑，占用ROM空间巨大！这个库提供了enIrqRegistration函数，用来绑定中断事件，以及中断处理函数。但要注意，调用它之前最好先调用enIrqResign函数，用来删除中断绑定关系，否则注册中断有可能会失败！

下面的代码，演示注册UART１的接收中断为81号中断，并指定中断处理函数为uart1_rx_handler

stc_irq_regi_conf_t irq_cfg;
irq_cfg.enIRQn      = Int081_IRQn;
irq_cfg.enIntSrc    = INT_USART1_RI;
irq_cfg.pfnCallback = uart1_rx_handler;
enIrqResign(Int081_IRQn);
enIrqRegistration(&irq_cfg);
NVIC_EnableIRQ(Int081_IRQn);

如果这个注册中断的时候可以给中断函数加上一个参数的话，实用性会大大提高，但是目前并不能，而一个中断事件绑定一个中断函数，又太占用ROM空间了，且很麻烦。

HC32F460串口驱动的问题

Mon, 07 Jun 2021 16:28:05 +0000

HC32F460片上有4路串口，驱动使用了HC32官方的库函数，一般初始化流程如下代码，一开始验证没有问题，能正常收发数据。

//HC32F460串口初始化
{
    stc_usart_uart_init_t init;
	memset(&init, 0, sizeof(init));
	
    init.enClkMode   = UsartIntClkCkNoOutput;
	init.enClkDiv    = UsartClkDiv_1;
	init.enDataLength= UsartDataBits8;
	init.enDirection = UsartDataLsbFirst;
	init.enStopBit   = UsartOneStopBit;
	init.enParity    = (en_usart_parity_t)parity;
	init.enSampleMode= UsartSampleBit8;
	init.enDetectMode= UsartStartBitFallEdge;
	init.enHwFlow    = UsartRtsEnable;
	USART_UART_Init(hw->uart, &init);

	USART_SetBaudrate(hw->uart, baudrate);
	USART_FuncCmd(hw->uart, UsartTx, Enable);
	USART_FuncCmd(hw->uart, UsartRx, Enable);
	USART_FuncCmd(hw->uart, UsartRxInt, Enable);
}

后来实际项目中，接入一个RS485设备，发现不能正常接收数据，故障表现是MCU不进接收中断。检查了硬件，没有发现问题，外部设备->板载485芯片->MCU_RX，示波器都能看到引脚有波形过来。最后通过Keil的外设查看窗口，看看UART的寄存器，发现SR->FE标记置1。这意味着接收发现帧错误。

于是怀疑是波特率的问题了，用串口调试工具测试发现，果然UART在9600波特率下不能正常接收。之前验证驱动用的是115200，波特率较高收发都正常。问题发生在下面这一行代码，UART的时钟分频值太低，无法产生9600这么低的波特率。

init.enClkDiv    = UsartClkDiv_1;

将这个值改为16，结果可以通信了。

init.enClkDiv    = UsartClkDiv_16;

后来把常用的波特率低至1200，高至921600都试了一遍。最终采取如下初始化代码：如果波特率低于115200，则分频值取64，高于等于115200则分频值取1。

    stc_usart_uart_init_t init;
	memset(&init, 0, sizeof(init));
	init.enClkMode   = UsartIntClkCkNoOutput;
	init.enClkDiv    = (baudrate < 115200) ? UsartClkDiv_64 : UsartClkDiv_1;
	init.enDataLength= UsartDataBits8;
	init.enDirection = UsartDataLsbFirst;
	init.enStopBit   = UsartOneStopBit;
	init.enParity    = (en_usart_parity_t)parity;
	init.enSampleMode= UsartSampleBit8;
	init.enDetectMode= UsartStartBitFallEdge;
	init.enHwFlow    = UsartRtsEnable;
	USART_UART_Init(hw->uart, &init);
	USART_SetBaudrate(hw->uart, baudrate);
	USART_FuncCmd(hw->uart, UsartTx, Enable);
	USART_FuncCmd(hw->uart, UsartRx, Enable);
	USART_FuncCmd(hw->uart, UsartRxInt, Enable);

C语言计算char/short/int的最大值和最小值

Thu, 03 Jun 2021 18:19:55 +0000

假设我们不知道目标平台的char、short、int长度是多少个字节，如何得到这个类型的最大值和最小值？

简单思考过后，我觉得可以采用无符号的最大值再右移1位的方式来得到有符号整数的最大值，把这个值取反又能得到最小值。使用下面的C语言代码进行验证，发现打印值是正确的。把代码中的 int 换成 char 和 short 都能正常打印出最大值和最小值。

void main(void)
{
	unsigned int tmp;
	int max_val;
	int min_val;
	tmp = 0 - 1;
	tmp = tmp >> 1;
	max_val = tmp;
	min_val = ~tmp;
	printf("min=%d, max=%d\n", min_val, max_val);
	system("pause");
}

华大HC32F460看门狗的使用

Fri, 21 May 2021 09:53:37 +0000

由于STM32涨价，厂家纷纷换了国产MCU，现在用华大HC32系列已经是潮流了。用惯了STM32，突然换其它MCU，总是要踩一些坑，来看看HC32的看门狗吧。

HC32F460有两个看门狗：SWDT和WDT SWDT使用的是内部专用RC时钟源，大约为10KHz，精度低，不受外部晶振和PLL的影响，可靠性较高 WDT使用的是系统时钟PCLK3，精度高，但如果晶振或PLL故障，看门狗会停止计数。

做为系统死机守护的看门狗，建议选用SWDT。

SWDT是16位递减计数器，计数值只能选择：256、4096、16384、65536这几种，不能任意设置。时钟分频可选：1、16、32、64、128、256、4096。看门狗复位时间(秒)=分频 * 计数值 / 10K

下面就是HC32460的特别之处了： SWDT的初始化和启动是完全由硬件完成的。 参数配置是由一个叫ICG的特殊FLASH区域来完成。 ICG地址0x00000400 - 0x0000041F，可以看作是8个32位的只读寄存器，其中只有前2个有作用。

要启动SWDT看门狗，就要配置ICG0寄存器，ICG0的BIT[12:0]如图所示：

只要把ICG0的最低位由1改为0，SWDT就会自动启动。关于ICG寄存器的配置方法，官方SDK已经提供了一个文件：hc32f460_icg.c和hc32f460_icg.h 修改hc32f460_icg.h的如下内容：

最后，还要记得修改ddl_config.h，打开配置开关。

#define DDL_ICG_ENABLE                              (DDL_ON)
#define DDL_SWDT_ENABLE                             (DDL_ON)

至此，SWDT看门狗就会自动自动启动了，程序要运行的时候，需要定时刷新看门狗计数值，刷新计数值使用以下函数就可以了： SWDT_RefreshCounter();

Win10PE纯64位无法重命名文件夹

Thu, 08 Apr 2021 11:02:34 +0000

基于WIN10_x64系统制作的PE系统，完全删掉SysWOW64，只保留纯64位系统，注册表也删掉关于WOW64和32位相关的项。结果进入PE发现无法给文件夹改名，但文件可以正常改名，用cmd命令ren也可以改名。

经过一番测试，结果发现与如下注册表有关：添加红框内的项，问题解决。

WinPE系统的自动打包和测试的批处理脚本

Fri, 02 Apr 2021 12:53:46 +0000

在制作WINPE系统的时候，通常是用虚拟机来测试。

纯手工操作有以下步骤：

1.修改注册表或者修改文件等一系列增删改操作。 2.手动用wim工具打包成boot.wim 3.手动挂载虚拟机的VHD硬盘文件 4.把boot.wim复制到虚拟机硬盘的指定目录 5.卸载VHD硬盘文件

手工操作确实很烦琐，点鼠标点到手抽筋。所以我们需要一个自动化脚本来完成以上操作。

以下批处理脚本就是用来干这个事情的，内容仅供参考：

@echo off
title WinPE镜像打包工具

REM 设置工作环境变量
set VHD_PATH="D:\VBOX\BOOT\BOOT.VHD"
set WIM_PATH="G:\BOOT\BOOT.WIM"

REM 生成挂载VHD的脚本
echo select vdisk file=%VHD_PATH% > bin\mount.txt
echo attach vdisk >> bin\mount.txt
echo list disk >> bin\mount.txt
REM 生成卸载VHD的脚本
echo select vdisk file=%VHD_PATH% > bin\unmount.txt
echo detach vdisk >> bin\unmount.txt

:MENU
echo ***********************************************************
echo * WinPE制作主菜单
echo ***********************************************************
echo * VHD路径: %VHD_PATH%
echo * WIM路径: %WIM_PATH%
echo ***********************************************************
echo * 1.导出注册表
echo * 2.重建注册表
echo * 3.打包WIM镜像
echo * 4.挂载VHD磁盘
echo * 5.卸载VHD磁盘
echo * 6.复制WIM到VHD
echo * 7.一键打包WIM+复制到VHD
echo * 8.一键重建注册表+打包WIM+复制到VHD
echo ***********************************************************
set /p menu=请选择功能:

if %menu%==1 (
    call :DO_REG_DUMP
    pause
    cls
)
if %menu%==2 (
    call :DO_REG_PACK
    pause
    cls
)
if %menu%==3 (
    call :DO_VIM_PACK
    pause
    cls
)
if %menu%==4 (
    call :DO_VHD_MOUNT
    pause
    cls
)
if %menu%==5 (
    call :DO_VHD_UNMOUNT
    pause
    cls
)
if %menu%==6 (
    call :DO_VHD_MOUNT
    call :DO_VIM_COPY
    call :DO_VHD_UNMOUNT
    pause
    cls
)
if %menu%==7 (
    call :DO_VIM_PACK
    call :DO_VHD_MOUNT
    call :DO_VIM_COPY
    call :DO_VHD_UNMOUNT
    pause
    cls
)
if %menu%==8 (
    call :DO_REG_PACK
    call :DO_VIM_PACK
    call :DO_VHD_MOUNT
    call :DO_VIM_COPY
    call :DO_VHD_UNMOUNT
    pause
    cls
)
goto MENU

:DO_REG_DUMP
echo -----------------------------------------------------------
echo 正在导出注册表...
reg load HKLM\PE_DEFAULT "boot\windows\system32\config\DEFAULT"
reg load HKLM\PE_SOFTWARE "boot\windows\system32\config\SOFTWARE"
reg load HKLM\PE_SYSTEM "boot\windows\system32\config\SYSTEM"
reg export HKLM\PE_SYSTEM "boot\windows\system32\config\SYSTEM.reg" /y
reg export HKLM\PE_DEFAULT "boot\windows\system32\config\DEFAULT.reg" /y
reg export HKLM\PE_SOFTWARE "boot\windows\system32\config\SOFTWARE.reg" /y
reg unload HKLM\PE_DEFAULT
reg unload HKLM\PE_SOFTWARE 
reg unload HKLM\PE_SYSTEM 
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

:DO_REG_PACK
echo -----------------------------------------------------------
echo 正在重建注册表...
copy /y boot\windows\system32\config\SAM boot\windows\system32\config\DEFAULT
copy /y boot\windows\system32\config\SAM boot\windows\system32\config\SOFTWARE
copy /y boot\windows\system32\config\SAM boot\windows\system32\config\SYSTEM
reg load HKLM\PE_DEFAULT "boot\windows\system32\config\DEFAULT"
reg load HKLM\PE_SOFTWARE "boot\windows\system32\config\SOFTWARE"
reg load HKLM\PE_SYSTEM "boot\windows\system32\config\SYSTEM"
reg import "boot\windows\system32\config\SYSTEM.reg"
reg import "boot\windows\system32\config\DEFAULT.reg"
reg import "boot\windows\system32\config\SOFTWARE.reg"
reg unload HKLM\PE_DEFAULT
reg unload HKLM\PE_SOFTWARE 
reg unload HKLM\PE_SYSTEM 
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

:DO_VIM_PACK
echo -----------------------------------------------------------
echo 正在打包WIM......
bin\wimlib.exe capture boot boot.wim --boot --wimboot 
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

:DO_VIM_COPY
echo -----------------------------------------------------------
echo 正在复制WIM到VHD...
xcopy boot.wim %WIM_PATH% /Y
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

:DO_VHD_MOUNT
echo -----------------------------------------------------------
echo 正在挂载VHD......
diskpart /s bin\mount.txt
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

:DO_VHD_UNMOUNT
echo -----------------------------------------------------------
echo 正在卸载VHD...
diskpart /s bin/unmount.txt
echo 操作完成
echo -----------------------------------------------------------
exit /b 0

使用说明：

RS485-MODBUS协议总结

Fri, 26 Feb 2021 12:54:49 +0000

简介

Modbus是一种串行通信协议，是Modicon公司（现施耐德电气）于1979年发表的。目前Modbus已经成为工业领域通信协议的业界标准，并且是工业电子设备之间常用的连接方式。

Modbus协议的通信机制是主从模式，在一条链路上可以挂载多个设备，其中有且只有一个主设备，其余设备均为从设备。在通信过程中，所有命令均由主设备发起，从机设备只能被动接收并响应主设备发起的命令。

Modbus协议的数据帧格式有两种类型：一种是ASCII类型，数据类型使用字符串输出。一种是RTU类型，数据类型使用二进制输出。目前常用的是RTU类型，二进制方式通信数据量更小，更紧凑。

Modbus协议并没有对链路层提出要求，它可以是RS485，也可以是RS232甚至是TCP/IP。目前最常用的是RS485，因为RS485通信距离远，抗干扰能力强，成本低。

本文以下内容针对RS485-MODBUS-RTU做一些总结

RTU数据帧格式 ：

子地址	功能码	数据包	校验字
1字节	1字节	N字节	2字节

示例数据：0x110x010x00 0x00 0x00 0x060xBE 0x98

子地址：0x00表示广播地址，0x01-0xF7表示从机地址，0xF8-0xFF用户自定义。功能码：表示此次通信需要使用从机的哪些功能，具体含义因设备而异。数据包：表示此次通信需要用到的数据，具体含义因设备和功能而异。校验字：表示CRC16计算的校验结果，低字节在前，高字节在后。参与CRC16计算的为：子地址+功能码+数据包

1.从帧格式可以看出来，没有固定帧头，也没有帧长字段，那么接收程序怎么判定帧起始和结束？协议规定两个字节之间的传输间隔大于传输4个字节所需的时长，则认为当前帧结束。注意：由于接收端需要用字节间隔时间来判断帧层，因此在发送数据时，最好关闭MCU中断，或者使用硬件DMA发送，避免发送中过程中被其它任务打断。传输时的波特率越高，间隔时长则越短。

2.接收到完整数据后要怎么验证完整性？验证CRC16校验值，crc16(子地址+功能码+数据包)，计算结果与最后2个字节进行对比，如果相同则认为数据包完整，进行下一步处理。否则数据包有误，应该丢弃这包数据。

3.CRC16具体是怎么计算的呢？参考如下代码：

unsigned int modbus_crc16(unsigned char *buff, unsigned int len)
{
	unsigned int crc = 0xFFFF;
	unsigned int i, j;
	for ( j = 0; j < len; j ++)
	{
		crc = crc ^ buff[j];
		for ( i = 0; i < 8; i++)
		{
			if( ( crc & 0x0001) > 0)
			{
				crc = crc >> 1;
				crc = crc ^ 0xa001;
			}
			else
			{
				crc = crc >> 1;
			}
		}
	}
	return crc;
}

监控远程桌面连接并通过python发送提醒邮件

Tue, 19 Jan 2021 13:00:45 +0000

由于RDP远程桌面功能非常方便，但又存在较高风险，只能通过提高安全防护，避免造成损失。本文记录一种邮件提醒远程登陆的方法和过程。工作原理： 1.利用windows的计划任务功能，当远程登陆的时候，调用指定的程序； 2.此处调用的是python脚本，利用python来完成发送邮件的功能； 3.在python脚本中调用一个EXE小程序来获取登陆信息（用户名，客户端名称等信息），

第一步：

写一个EXE小工具，获取远程登陆信息使用C语言编写，通过win32底层API读取客户端信息；并把信息打印到标准输出以便后面python读取。这个方法不能获取到准确的客户端IP地址，这里的IP地址其实是内网地址。暂时还没有找到如何获取客户端公网IP的办法。完整的C语言源码如下（只支持Windows Vista及以上系统版本）：

#include <stdio.h>
#include <Windows.h>
#include <wtsapi32.h>

#pragma comment(lib, "wtsapi32.lib")

static const char *af_str[]=
{
"AF_UNSPEC",
"AF_UNIX",
"AF_INET",
"AF_IMPLINK",
"AF_PUP",
"AF_CHAOS",
"AF_IPX",
"AF_NS",
"AF_ISO",
"AF_OSI",
"AF_ECMA",
"AF_DATAKIT",
"AF_CCITT",
"AF_SNA",
"AF_DECnet",
"AF_DLI",
"AF_LAT",
"AF_HYLINK",
"AF_APPLETALK",
"AF_NETBIOS",
"AF_VOICEVIEW",
"AF_FIREFOX",
"AF_UNKNOWN1",
"AF_BAN",
};

void main(void)
{
	DWORD cbReturned; 
	PWTSCLIENTA pData;
	if(WTSQuerySessionInformationA(WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTSClientInfo, (LPSTR*)&pData, &cbReturned))
	{
		printf("UserName:%s\r\n", pData->UserName);
		printf("ClientName:%s\r\n", pData->ClientName);
		printf("ClientBuildNumber:%d\r\n", pData->ClientBuildNumber);
		printf("ClientAddressFamily:%s\r\n", af_str[pData->ClientAddressFamily]);
		printf("ClientAddress(raw):%d.%d.%d.%d\r\n", pData->ClientAddress[0],pData->ClientAddress[1],pData->ClientAddress[2],pData->ClientAddress[3]);
		printf("ClientAddress(str):%ls\r\n", pData->ClientAddress);
		WTSFreeMemory(pData);
		return;
	}
	printf("WTSQuerySessionInformationA Failed!\r\n");
	printf("Error:%08X\r\n", GetLastError());
	//system("pause");
}

第二步：

写一个python脚本，调用上面的小工具，并读取输出，然后发送邮件。发送邮件使用了网易的STMP服务，用自己的邮箱账号给自己的另一个邮箱发。接收邮件最好用QQ邮箱，QQ邮件手机可以及时接收到邮件。完整python源码如下：

MDK安装包的精简以及绿化方法

Fri, 15 Jan 2021 15:12:27 +0000

Keil MDK5 安装包越来越大, 全新安装非常耗时. 但实际上MDK5完全不写注册表,明明解压就可用. 安装过程主要是在解压文件.只需要设置好TOOLS.INI中的路径就可以了. 把它做成精简绿色优化版.以后重装系统都不用重装MDK. 软件版本基于MDK5.18

1.绿化

解压到任意英文目录后,修改TOOLS.INI中的路径配置即可运行UV4.exe.

[UV2]
ARMSEL=1
USERTE=1
RTEPATH=这里是设备支持包的路径
[ARM]
LIC0=
[ARMADS]
PATH=这里是ARM路径
PATH1=这里是编译器路径

2.优化

关于MDK的菜单栏也吐槽很久了,官方原版的菜单字体和风格都不跟随系统主题, 所以给它打个补丁让它的菜单和系统主题保持一致.

下图左边是原版菜单, 右边是修改后的菜单.

<左—右>

除了菜单栏,还有一个问题,就是MDK默认仿真器是ULINK,而我使用的是JLINK. 每次修改目标CPU后,又被重置为ULINK,很麻烦. 所以我把JLINK设置为默认仿真器,并且删除了ULINK.

3.精简

MDK完整安装后,有很多文件其实是用不到的.比如一些帮助文件…. 删除了帮助文件和一些不相干的文件. 删除了C++库和头文件. 删除了JLink以外的仿真器. 删除了自带的CMSIS软件包.

精简绿色版Keil.MDK.V5.18_keil5绿色版-C工具类资源-CSDN下载

记一次勒索病毒的遭遇

Thu, 14 Jan 2021 14:10:07 +0000

快放假了，为了方便用手机远程电脑抢火车票，就在电脑上开启了远程桌面连接，并且做了内网端口映射。但是抢完票又是周末，忘记关机，周一大早发现电脑登陆不进去了，而且屏幕显示用户已远程登陆…（心中感觉不妙）邓上重启电脑，发现BOOTMGR is missing… 马上U盘启动，进入WinPE一看，啊，完蛋了！本地硬盘上的所有文件全部被加密了！文件后缀全部变为了id[828CB570-2700].[helpbackup@email.tg].Devos 这太TM过分了啊！我的资料和代码全没了啊！去年的wannacry勒索病毒的新闻还历历在目，没想到这就让我遇上了，哎！！！因为电脑屏幕是锁屏状态，我无法登陆，所以我连勒索我的那个弹窗都没看到，不知道他到底要多少比特币…… 不过所幸的是一些重要的文件我已经备份到网盘里了，但是还有很多没有备份的文件丢失了，只能慢慢重头再来了。

花了一整天时间，重做系统，格式化硬盘，找回那些已备份的文件……

事后反思：

我的系统虽然是win7，但已经打了永恒之蓝和RDP漏洞补丁。所以这病毒大概率是利用RDP远程扫描工具，找到了我的端口，并且使用密码字典进行爆破，拿到了登陆账号和密码，然后手动投毒。因为我的登陆密码真是太弱了！本来就是打算临时用一下，用完就关闭，结果却发生了最坏的情况。暴露在公网的资源，真的是大意不得，稍有不慎，便会带来严重的损失！！！ 1.无论如何不要使用弱密码； 2.尽可能开启IP访问白名单，特别是要拉黑国外的IP地址； 3.不使用的时候，尽量关机； 4.要提高文件备份的频率和覆盖面；

事已至此，虽然这种文件暂时还没有解密的办法，但我还是要稍微对它了解一下.

从文件的修改时间来看，加密过程是从凌晨3点到4点，整个过程只花了1个小时！这加密速度也太快了吧，电脑硬盘文件估计有几百个GB，全部加密只花了1个小时？

所有文件都在原始文件名末尾添加了一串用于解密的信息：id[828CB570-2700].[helpbackup@email.tg].Devos 828CB570-2700应该是机器码一类的 helpbackup@email.tg应该是黑客的邮箱 devos应该是特征后缀名

通过奇安信的在线查询网页，显示此勒索病毒是phobos，暂时无法解密！

再看看文件内容，找一个已知内容的文件进行对比，发现文件内容变成面貌全非，并且文件长度也发生了变化。文件长度增加了258字节，应该是添加了一串解密的信息在里面。

再找一个比较大一点的文件，这个文件有20MB。发现文件前面256KB的内容全变为了00，中间也有一段变为了00，末尾又有一段全为00的数据，而其余部分的内容并没有改变？嘻嘻，这样的话似乎还能还原一小部分文件内容？在末尾又新增加了一段数据，猜测是变为了00的这三段数据加密后的内容。

通过多次测试，发现文件大于2MB的，全部采用部分加密的算法，而小于2MB的文件，则采取整体加密的算法，所以这就是实现快速全盘加密的方案？不然有一些1GB以上的超大文件，加密肯定会很耗时。

完。

补充：后来在整理被加密的文件时，发一个隐藏目录下发现了2个高度可疑的未加密EXE文件，极有可能就是phobos病毒文件。有兴趣的可以下载下来看看是不是：链接: https://pan.baidu.com/s/1eA6Y6lJzVCJ_VJfnm3fzTg 提取码: tqpv 里面包fast.exe和ns.exe两个文件，fast.exe应该就是病毒本身，而ns.exe应该是用于搜索和挂载局域网内的SMB共享文件夹的小工具。

Python_3.8.6_x86精简绿色版

Fri, 08 Jan 2021 11:53:41 +0000

之前做的Python_3.6.8版本没有集成IDLE环境，这次重新使用官方3.8.6版本打包了一个带IDLE工具的绿色版本。 python 3.8版本比3.6版本有较大的性能提升，因此推荐使用3.8版本。

说明：

用原版python3.8.6_x86安装后精简而成。 1.添加了绿色补丁，可正常使用pip工具。 2.自带IDLE开发学习环境。 3.使用时解压到任意非中文目录，无需设置环境变量。 4.运行prompt.bat可进入带python环境的控制台。 5.要使用IDLE直接运行idle.bat即可。 6.运行install.bat可添加python环境到右键菜单。注意：需要安装VC++2015，否则提示缺少VCRUNTIME140.dll

本来打算传CSDN，设置零积分下载，竟然不让我传，只能传微云网盘了下载地址： https://share.weiyun.com/YmBfgEWm

降低洛达1562方案AirPods声音延迟的办法

Wed, 30 Dec 2020 11:25:10 +0000

最近入手了一款国产蓝牙耳机，采用洛达方案的二代”AirPods“算是性价比很高的蓝牙耳机了。

老的1536U方案以及现在新的1562M方案实际使用效果都不错。

1562M降低了功耗，耳机续航时间达到5-6小时，超越了原版。

蓝牙耳机会有声音延迟是正常现象。

正常模式下声音延时，听歌是没有问题的，不过玩游戏时能感觉到轻微的延时，估计在200毫秒左右。

1562的固件里面其实是有低延迟游戏模式的，只不过正常情况下并没有开启，使用洛达原厂的SDK工具，可以设置此模式。

此工具仅支持洛达芯片，可用于检测耳机是不是真洛达。

工具下载： https://download.csdn.net/download/qq446252221/13984216

警告：使用原厂SDK工具设置参数有风险，请自行判断风险再下载使用！

使用工具连接前，先使用系统蓝牙与耳机配对并连接，才能正常使用工具。

安装好工具软件后，打开界面如下：

第1步：连接耳机，点击SPP，弹出耳机列表，选中你的AirPod

第2步：点击CONNECT，连接成功会显示绿色的Target BDA: xx:xx:xx:xx:xx字样。

连接成功后，点击MMI UT，可以看到耳机信息和参数配置：

如下图所示，芯片型号为AB1562M，固件版本130.1.1.32

往下滑，翻到页面最底部，就可以看到低延时模式的设置选项：

默认都是Normal Mode(正常模式)，

手动切换为Low Latency Mode(低延时模式)，然后点SET LATENCY STATUS设置模式。

设置完之后，退出软件，就会发现游戏声音延时稍微降低了，大约还是有100多毫秒。

注意：这个模式设置不能永久保存，每次从盒子里拿出来，都要重新设置一次。

用python代替批处理脚本调用ffmpeg批量转换文件

Fri, 25 Dec 2020 14:41:17 +0000

需求：把指定文件夹下面的所有MP4文件无损转换为TS文件

用windows批处理脚本也能实现，不过为了学习python，当然要多写多用。

脚本思路很简单： 1.先输入要处理的文件夹 2.读取该文件夹下面的所有文件 3.遍历文件名,检查后缀是不是mp4 4.如果后缀是mp4则调用ffmpeg进行文件转换

调用ffmpeg进行mp4转ts的参数：ffmpeg.exe -v error -y -i file.mp4 -c copy file.ts 其中： -v error 表示只打印错误日志，不加这个ffmpeg会在控制台输出很多日志。 -y 表示如果输出文件已经存在则直接替换，不加这个ffmpeg会询问yes/no，需要手动输入。 -i file.mp4 指定要转换的mp4文件路径 -c copy 表示不进行重编码，仅容器格式转换 file.ts 表示输出TS文件的路径

参考代码如下：

#!python
#批量调用ffmpeg，转换MP4为TS格式
#蒋晓岗<kerndev@foxmail.com>
import os

#设置ffmpeg路径
EXE_PATH="D:\\ANSI\\FFmpeg\\ffmpeg.exe"

#调用ffmpeg
def call_ffmpeg(exe_path, src_path, dst_path):
	cmd_line = '%s -v error -y -i "%s" -c copy "%s"' % (exe_path, src_path, dst_path)
	ret = os.system(cmd_line)
	if ret == 0:
		print("-转换成功.")
		return True
	else:
		print("-转换失败:", ret)
		return False

#转换目录内的所有文件
def process_dir(exe_path, src_dir, dst_dir):
	print("处理目录:", src_dir)
	
	if not os.path.exists(src_dir):
		print("该目录不存在!")
		return

	if not os.path.exists(dst_dir):
		os.mkdir(dst_dir)

	mp4_list = os.listdir(src_dir)
	for file in mp4_list:
		if file.endswith(".mp4"):
			print("+转换文件:", file)
			src_path = src_dir + file
			dst_path = dst_dir + file + ".ts"
			call_ffmpeg(exe_path, src_path, dst_path)
			
	print("处理目录完成.")

#程序入口
src_dir = input("输入目录:") + "\\"
dst_dir = input("输出目录:") + "\\"
process_dir(EXE_PATH, src_dir, dst_dir)

最后，python大法好！

在Keil MDK中无法使用gmtime函数进行时间戳转换

Thu, 24 Dec 2020 14:17:14 +0000

硬件平台STM32，软件平台Keil MDK 5.18

由于项目中需要用到UNIX时间戳和日历的来回转换，于是想到C库函数<time.h>里面有现成的函数可以使用。

于直接使用mktime和gmtime两个函数进行时间戳转换，前者把日历转为时间戳，后者把时间戳转为日历。

但是程序运行起来发现，gmtime得到的日历数据为乱码！！！

经过调试才发现，这个函数返回值是NULL啊！！！

查看反汇编代码，简直惊呆，这是什么鬼操作？

汇编代码没有函数跳转，取而代之的是MOVS R0, #0x00，直接返回0。

看到这一幕，气炸，搞了个假的库函数给我啊。

于是马上又换成另一个时间戳转转函数localtime，经测试发现这个函数工作得很好！

gmtime和localtime的区别就是，gmtime返回的是GMT标准时间，而localtime返回的是本地时间。

何为本地时间？那就是带时区转换的时间，比如北京时间是东8区，与GMT时间相差8小时。

然而MDK库函数并没有直接设置时区的函数，因此locatime返回的仍然是GMT时间。

所以在使时localtime的时候，要先把时间戳加上28800秒（8小时）再进行转换，就能得到北京时间。

最后附上日历和时间戳相互转换的代码：

日历转时间戳

日历转时间戳使用mktime函数，参考代码如下：

void date_to_timestamp(struct date *date, uint32_t *timestamp)
{
	time_t times;
	struct tm tm;
	tm.tm_year = date->year - 1900; //C库函数的年份是从1900开始计算
	tm.tm_mon  = date->month - 1;   //C库函数的月份是用0表示1月
	tm.tm_mday = date->day;
	tm.tm_hour = date->hour;
	tm.tm_min  = date->minute;
	tm.tm_sec  = date->second;
	times = mktime(&tm);
	*timestamp = times - 28800;    //北京时间:东8区偏移值
}

时间戳转日历

时间戳转日历使用localtime函数，参考代码如下：

void timestamp_to_date(uint32_t timestamp, struct date *date)
{
	time_t times;
	struct tm *tm;
	times = timestamp + 28800;
	tm = localtime(&times);
	date->year   = tm->tm_year + 1900;
	date->month  = tm->tm_mon + 1;
	date->day    = tm->tm_mday;
	date->hour   = tm->tm_hour;
	date->minute = tm->tm_min;
	date->second = tm->tm_sec;	
}

PS：如果需要使用毫秒级的时间戳，可以直接把这个秒级的时间戳乘以1000，倒过来则除以1000。

如何从HardFault异常中定位到错误代码

Fri, 18 Dec 2020 16:43:28 +0000

调试Cortex-M处理器的程序，最常见的异常就是HardFault错误，这种错误一般是因为非法访问内存或者非法指令引起的，比如写空指针，程序跑飞等情况。但常常出现HardFault异常后，难以直接定位到出错代码，只能通过读取栈顶数据来定位错误代码。那么发生HardFault异常的栈顶数据该怎么解读？

在Cortex-M相关文档中异常模型章节可以找到一张图表，下图是Cortex-M4当异常发生时，硬件会自动往栈顶写入的数据结构。从图中可以看出Cortex-M4有两种模式，一种是带FPU指针的结构，另一种是不带FPU的结构，其中不带FPU的结构和Cortex-M3是完全一样的。即便两种模式的栈结构稍有差异，但其实栈顶的前8个数据都是一样的，分别是R0,R1,R2,R3,R12,LR,PC。在发生HardFault错误时，我们最关心的就是LR和PC的值，PC代表发生错误的那条指令，LR代表当前函数返回后的下一条指令地址。

下面用实例来说明如何从HardFault错误时的栈顶数据找到出错代码。用Keil写一段测试代码如下，bad函数指针指向无效地址，会引起非法指令异常，进入HardFault。

/*
* HardFault错误演示
* 蒋晓岗<kerndev@foxmail.com>
*/
#include <string.h>

typedef void (*bad_func)(void);

//跳转到无效地址,程序跑飞
void fault(void)
{
	bad_func bad;
	bad = (bad_func)0xDEADDEAD;
	bad();
	memset(bad, 0, sizeof(bad));
}

int main(void)
{
	fault();
	while(1);
}

看看运行时的效果，程序一运行，马上就进入HardFault_Handler，此时查看实时寄存器的值SP=0x200003F0，PC=0x08080236这是一条死循环指令；然后在右边的内存查看窗口中输入SP，按回车可以看到栈顶的内存数据，第一个数据20000060就是发生异常时R0寄存器的值，下面依次是R1,R2,R3,R12,LR,PC。要定位到出错的代码，重点关注PC和LR的值。栈顶数据中 PC=0xDEADDEAC，LR=0x080802E7.

在得到HardFault异常发生时的PC和LR值之后，我们就可以去反汇编窗口，右键选择“Show Disassembly at Address”，手动输入地址直接定位到该错误指令。首先看PC=0xDEADDEAC，这是一个无效地址。即使我们用反汇编去查看这个地址也是看不到任何有效汇编指令的，由此断定我们的程序一定是跑飞了。但是为什么跑飞呢，我们只能继续分析LR的值，来寻找答案。

然后看LR=0x080802E7，幸好这是一个位于FLASH代码段的地址，在反汇编地址中输入0x080802E6。注解：为什么不是输入0x080802E7呢？因为LR的最低位表示的是指令类型ARM/Thumb，通常最低位都是1，因此要减去1。

从汇编窗口可以看到，LR指向的指令是MOVS R0,#0x00，通常情况下引发异常的元凶是它的上一条指令，BLX R4，这是一个函数调用，引发HardFault异常的元凶就是这个函数调用，跳转到R4寄存器所指示的地址。由于R4寄存器的值不在栈里保存，只能查看实时寄存器的值，左侧显示R4=0xDEADDEAD。那么这就真相大白了，BLX跳转到0xDEADDEAD地址，该地址是无效地址，从该地址读取不到合法的指令，因此引发HardFault异常。

注：明明跳转的地址是0xDEADDEAD，而HardFault之后栈顶PC的值是0xDEADDEAC呢？因为Cortex-M是Thumb2指令集，是2字节对齐的，跳转指令会自动进行字节对齐。实际传入PC的值就是0xDEADDEAC。

总结：

当程序进入HardFault异常时，我们可以通过在线调试器，读取SP内存，找到引发异常的PC指针，定位到错误的指令。

如果此时PC指针是无效地址，那么还可以通过LR返回地址，推测出现异常的函数调用。

win32实现飘浮文字的一种实现方法

Wed, 02 Dec 2020 14:40:09 +0000

飘浮文字效果如下图：不可点击，不可选中，任务栏不显示图标，文字背景完全透明。

实现方法是通过创建透明窗口来实现，在透明窗口上绘制文字。

主要依靠系统提供的窗口扩展风格：

WS_EX_LAYERED 实现层级窗口 WS_EX_TRANSPARENT 实现鼠标穿透 WS_EX_TOOLWINDOW 实现不在任务栏显示 WS_EX_TOPMOST 实现文本置顶

还有一个关键函数SetLayeredWindowAttributes(hWnd,0,0,LWA_COLORKEY);

这个函数设置层级窗口的透明模式为COLORKEY，第2个参数指定的COLORKEY的颜色。

在该窗口上绘制的COLORKEY颜色会被显示为透明，其它颜色则正常显示。

代码如下：

/************************************************************************
* Windows桌面飘浮文字DEMO
* 实现类似于弹幕的透明文字
* kerndev@foxmail.com
************************************************************************/

#define WINVER       0x0501
#define _WIN32_WINNT 0x0501

#include <windows.h>
#include <tchar.h>

//全局变量
HINSTANCE hInst;
UINT nDesktopWidth;
UINT nDesktopHeight;

//绘制文本
static void FLOATTEXT_OnPaint(HWND hWnd)
{
	HDC hdc;
	int len;
	TCHAR text[256];
	PAINTSTRUCT ps;
	hdc = BeginPaint(hWnd,&ps);
	SetBkMode(hdc,TRANSPARENT);
	SetTextColor(hdc,RGB(255,0,0));
	SelectObject(hdc, GetStockObject(SYSTEM_FIXED_FONT));
	len = GetWindowText(hWnd,text,256);
	TextOut(hdc,0,0,text,len);
	EndPaint(hWnd,&ps);
}

//窗口定时器,移动窗口
static void FLOATTEXT_OnTimer(HWND hWnd)
{
	RECT rc;
	GetWindowRect(hWnd,&rc);
	if(rc.right < 0)
	{
		OffsetRect(&rc,-rc.left,0);
		OffsetRect(&rc,nDesktopWidth,0);
	}
	OffsetRect(&rc,-1,0);
	MoveWindow(hWnd,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,1);
}

//初始化窗口属性
static void FLOATTEXT_OnCreate(HWND hWnd, LPCREATESTRUCT cs)
{
	SetLayeredWindowAttributes(hWnd,0,0,LWA_COLORKEY);
	SetTimer(hWnd,0,25,NULL);
}

//窗口回调函数
static LRESULT CALLBACK FLOATTEXT_WindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	switch(Msg)
	{
	case WM_CREATE:
		FLOATTEXT_OnCreate(hWnd, (LPCREATESTRUCT)lParam);
		return 1;
	case WM_TIMER:
		FLOATTEXT_OnTimer(hWnd);
		return 0;
	case WM_PAINT:
		FLOATTEXT_OnPaint(hWnd);
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hWnd,Msg,wParam,lParam);
}

//注册窗口类
BOOL FLOATTEXT_Init(void)
{
	WNDCLASS wc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	wc.hCursor = NULL;
	wc.hIcon   = NULL;
	wc.hInstance = hInst;
	wc.lpfnWndProc = FLOATTEXT_WindowProc;
	wc.lpszClassName = _T("FLOATTEXT");
	wc.lpszMenuName = NULL;
	wc.style = NULL;
	return RegisterClass(&wc);
}

//创建窗口
//WS_EX_LAYERED      实现窗口背景透明
//WS_EX_TRANSPARENT  实现鼠标穿透
//WS_EX_TOOLWINDOW   实现不在任务栏显示
//WS_EX_TOPMOST      实现文本置顶
BOOL FLOATTEXT_Create(LPCTSTR text, int y)
{
	HWND hWnd;
	DWORD dwStyle;
	DWORD dwExStyle;
	dwStyle = WS_POPUP;
	dwExStyle = WS_EX_LAYERED|WS_EX_TRANSPARENT|WS_EX_TOPMOST|WS_EX_TOOLWINDOW;
	hWnd = CreateWindowEx(dwExStyle,_T("FLOATTEXT"),text,dwStyle,nDesktopWidth,y,250,20,NULL,0,0,0);
	if(hWnd != NULL)
	{
		ShowWindow(hWnd,SW_SHOWNOACTIVATE);
		return TRUE;
	}
	return FALSE;
}

void AppInit(void)
{
	FLOATTEXT_Init();
	FLOATTEXT_Create(_T("漂浮文字<kerndev@foxmail.com>"),100);
}

void AppLoop(void)
{
	MSG msg;
	while(GetMessage(&msg, NULL, 0, 0))
	{
		DispatchMessage(&msg);
	}
}

int APIENTRY _tWinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPTSTR lpCmdLine,int nCmdShow)
{
	hInst = hInstance;
	nDesktopWidth = GetSystemMetrics(SM_CXSCREEN);
	nDesktopHeight= GetSystemMetrics(SM_CYSCREEN);
	AppInit();
	AppLoop();
	return 0;
}

LWIP使用TCP自带的KEEPALIVE功能

Tue, 01 Dec 2020 17:10:51 +0000

TCP_KEEPALIVE功能可以用来检测或保持基于TCP协议的客户端和服务器之间的链路畅通。

当客户端和服务器之间长时间没有数据通信时，协议栈会发送一个特殊的空数据包，用来检测链路是否正常。

接收到这个空数据包的一方会自动发送一个应答包，表示网络链路通信正常。

发送方如果在规定的时间内没有收到应答包，则表示链路中断，自动断开TCP连接，并通知应用层TCP连接断开。

整个交互逻辑完全在协议栈内完成，不需要在应用层做额外的工作，比较方便。

应用示例：

如下图所示，两个交换机中间的网线损坏，导致网络通信失败，客户端与服务器端均不知道网线已经断开。

只能通过应用层心跳包或者开启TCP_KEEPALIVE来实现断线检测。

LWIP目前的版本也支持TCP_KEEPALIVE功能，但默认是关闭状态。

要使用LWIP的TCP_KEEPALIVE功能，需要如下配置：

1.修改lwipopts.h添加以下内容：

//KEEPALIVE
#define LWIP_TCP_KEEPALIVE              1
#define TCP_KEEPIDLE_DEFAULT            3000    //3秒内双方无数据则发起保活探测
#define TCP_KEEPINTVL_DEFAULT           1000    //1秒发送一次保活探测
#define TCP_KEEPCNT_DEFAULT             3       //3次探测无响应则断开

2.创建TCP连接时，需要添加以下代码：

......
struct tcp_pcb *pcb;
pcb = tcp_new();
pcb->so_options |= SOF_KEEPALIVE; //开启TCP_KEEPALIVE标记
err = tcp_connect(ctx->pcb, &ip, port, lwip_tcp_connect_callback);
......

3.按照以上1，2方法开启KEEPALIVE功能之后，如果长时间没有发送或接收到数据，则会发起KEEPALIVE检测。

如果发送3次探测都没有收到应答，LWIP则会断开这条TCP连接，应用层会收到remote closed的回调事件。

电子称专用ADC芯片HX711驱动

Mon, 23 Nov 2020 09:10:01 +0000

简介

HX711是一个用于电子称的ADC芯片，分辨率为24bit，内置2个通道的低噪放大器，可选增益32/64/128倍。

通道A可选增益64倍或128倍。当增益为64倍时，满量程为±40mV；当增益为128倍时，满量程为±20mV。

通道B固定增益32倍。满量程为±80mV。

通信

HX711与MCU通信采用的是2线串行数据通信，一条时钟线(PD_SCK)，一条数据线(DOUT)。时序和SPI类似，但不是标准的SPI协议。

它要求每次通信至少25个时钟，至多27个时钟。前面24个时钟传送ADC采样数据，后面3个时钟决定下次采样的通道和增益。

ADC采样数据为24位有符号整数。

注意： 1.如果PD_SCK保持高电平超过60us，芯片会进入掉电模式。重新拉低PD_SCK芯片会重新上电并复位。 2.数据线DOUT必须使用上拉才能正常通信，可以使用MCU的上拉输入模式，也可以在硬件上连接外部上拉电阻。

代码

以下代码仅供参考：

硬件平台使用STM32，使用2个GPIO模拟时序读取采样数据，此处固定使用通道A，增益128。

#include "bsp.h"
#include "delay.h"

#define PIN_SCK PA,2
#define PIN_SDA PA,3

//连续发送25个时钟,读取ADC并设置下次采样为通道A，增益128
int hx711_recv(void)
{
	int i;
	uint32_t data;
	data = 0;
	gpio_write(PIN_SCK, 0);
	while(gpio_read(PIN_SDA));
	for(i=0; i<24; i++)
	{
		gpio_write(PIN_SCK, 1);
		delay_us(1);
		gpio_write(PIN_SCK, 0);
		delay_us(1);
		data <<= 1;
		data |= gpio_read(PIN_SDA);
	}
	gpio_write(PIN_SCK, 1);
	delay_us(1);
	gpio_write(PIN_SCK, 0);
	data <<= 8;
	return ((int)(data)) >> 8;
}

//初始化GPIO
void hx711_init(void)
{
	gpio_open(PIN_SDA, GPIO_MODE_IN, GPIO_IN_PULLUP);
	gpio_open(PIN_SCK, GPIO_MODE_OUT, GPIO_OUT_PP);
	gpio_write(PIN_SCK, 0);
}

LWIP+ENC28J60长时间运行后无法访问外网服务器

Tue, 17 Nov 2020 09:53:27 +0000

一台设备，硬件使用STM32+ENC28J60，协议栈使用LWIP-2.1.2版本。

作为TCP客户端与外网的服务器通信，正常运行了约2个月后，出现出法连接服务器的故障，

查看UART日志发现：使用lwip的函数tcp_connect建立连接，返回成功。但在等待连接成功的回调时，发生了error异常，错误代码是ERR_ABRT(-13)，一般表示连接超时。

1.重新插拔网线，可以正常检测到网线断开和连接，说明网口芯片工作正常，网口的绿灯和黄灯也正常点亮。

2.使用同局域网的电脑调用ping命令，可以正常ping通设备，再次说明网卡芯片是正常工作的，协议栈也没有崩溃。

3.使用参数配置工具，将设备内的服务器IP地址改为局域网内的电脑，并在该电脑上启动一个TCP服务器调试程序，发现设备可以正常连接到该电脑，通信也正常。

4.再次将设备内的服务器IP地址恢复为外网服务器，故障依旧，仍无法连接。

5.将设备的网线插入到用于调试电脑，该电脑可以正常访问外网服务器，说明外网服务器也没有问题。

6.无奈，只得重启设备，故障消失！

最终还是没能定位到问题所在，困扰中………………..

2020.12.29

经过一个多月的待机观察，终于发现了问题所在！

这个是应用层软件功能的设计缺陷，不是网卡问题，也不是LWIP协议栈问题。

本地的网关地址被修改了，导致无法访问外网！

C语言参考代码: 绘制直线、圆、椭圆、贝塞尔曲线(作者:Alois Zingl)

Thu, 22 Oct 2020 10:05:31 +0000

/********************************************************************
*                                                                   *
*                    Curve Rasterizing Algorithm                    *
*                                                                   *
********************************************************************/

/**
 * @author Zingl Alois
 * @date 22.08.2016
 * @version 1.2
*/

void plotLine(int x0, int y0, int x1, int y1)
{
    int dx =  abs(x1-x0), sx = x0<x1 ? 1 : -1;
    int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
    int err = dx+dy, e2;                                  /* error value e_xy */

    for (;;) {                                                        /* loop */
        setPixel(x0,y0);
        e2 = 2*err;
        if (e2 >= dy) {                                       /* e_xy+e_x > 0 */
            if (x0 == x1) break;
            err += dy; x0 += sx;
        }
        if (e2 <= dx) {                                       /* e_xy+e_y < 0 */
            if (y0 == y1) break;
            err += dx; y0 += sy;
        }
    }
}

void plotLine3d (int x0, int y0, int z0, int x1, int y1, int z1)
{
    int dx = abs(x1-x0), sx = x0 < x1 ? 1 : -1;
    int dy = abs(y1-y0), sy = y0 < y1 ? 1 : -1;
    int dz = abs(z1-z0), sz = z0 < z1 ? 1 : -1;
    int dm = dx > dy && dx > dz ? dx : dy > dz ? dy : dz, i = dm; /* max diff */
    x1 = y1 = z1 = dm/2;                                      /* error offset */

    for (;;) {
        setPixel(x0,y0,z0);
        if (i-- == 0) break;
        x1 -= dx; if (x1 < 0) { x1 += dm; x0 += sx; }
        y1 -= dy; if (y1 < 0) { y1 += dm; y0 += sy; }
        z1 -= dz; if (z1 < 0) { z1 += dm; z0 += sz; }
    }
}

void plotEllipse(int xm, int ym, int a, int b)
{
   int x = -a, y = 0;           /* II. quadrant from bottom left to top right */
   long e2 = (long)b*b, err = (long)x*(2*e2+x)+e2;         /* error of 1.step */

   do {
       setPixel(xm-x, ym+y);                                 /*   I. Quadrant */
       setPixel(xm+x, ym+y);                                 /*  II. Quadrant */
       setPixel(xm+x, ym-y);                                 /* III. Quadrant */
       setPixel(xm-x, ym-y);                                 /*  IV. Quadrant */
       e2 = 2*err;
       if (e2 >= (x*2+1)*(long)b*b)                           /* e_xy+e_x > 0 */
          err += (++x*2+1)*(long)b*b;
       if (e2 <= (y*2+1)*(long)a*a)                           /* e_xy+e_y < 0 */
          err += (++y*2+1)*(long)a*a;
   } while (x <= 0);

   while (y++ < b) {                  /* too early stop of flat ellipses a=1, */
       setPixel(xm, ym+y);                        /* -> finish tip of ellipse */
       setPixel(xm, ym-y);
   }
}

void plotOptimizedEllipse(int xm, int ym, int a, int b)
{
   long x = -a, y = 0;          /* II. quadrant from bottom left to top right */
   long e2 = b, dx = (1+2*x)*e2*e2;                       /* error increment  */
   long dy = x*x, err = dx+dy;                             /* error of 1.step */

   do {
       setPixel(xm-x, ym+y);                                 /*   I. Quadrant */
       setPixel(xm+x, ym+y);                                 /*  II. Quadrant */
       setPixel(xm+x, ym-y);                                 /* III. Quadrant */
       setPixel(xm-x, ym-y);                                 /*  IV. Quadrant */
       e2 = 2*err;
       if (e2 >= dx) { x++; err += dx += 2*(long)b*b; }             /* x step */
       if (e2 <= dy) { y++; err += dy += 2*(long)a*a; }             /* y step */
   } while (x <= 0);

   while (y++ < b) {            /* too early stop for flat ellipses with a=1, */
       setPixel(xm, ym+y);                        /* -> finish tip of ellipse */
       setPixel(xm, ym-y);
   }
}

void plotCircle(int xm, int ym, int r)
{
   int x = -r, y = 0, err = 2-2*r;                /* bottom left to top right */
   do {
      setPixel(xm-x, ym+y);                            /*   I. Quadrant +x +y */
      setPixel(xm-y, ym-x);                            /*  II. Quadrant -x +y */
      setPixel(xm+x, ym-y);                            /* III. Quadrant -x -y */
      setPixel(xm+y, ym+x);                            /*  IV. Quadrant +x -y */
      r = err;
      if (r <= y) err += ++y*2+1;                             /* e_xy+e_y < 0 */
      if (r > x || err > y)                  /* e_xy+e_x > 0 or no 2nd y-step */
         err += ++x*2+1;                                     /* -> x-step now */
   } while (x < 0);
}

void plotEllipseRect(int x0, int y0, int x1, int y1)
{                              /* rectangular parameter enclosing the ellipse */
   long a = abs(x1-x0), b = abs(y1-y0), b1 = b&1;                 /* diameter */
   double dx = 4*(1.0-a)*b*b, dy = 4*(b1+1)*a*a;           /* error increment */
   double err = dx+dy+b1*a*a, e2;                          /* error of 1.step */

   if (x0 > x1) { x0 = x1; x1 += a; }        /* if called with swapped points */
   if (y0 > y1) y0 = y1;                                  /* .. exchange them */
   y0 += (b+1)/2; y1 = y0-b1;                               /* starting pixel */
   a = 8*a*a; b1 = 8*b*b;

   do {
      setPixel(x1, y0);                                      /*   I. Quadrant */
      setPixel(x0, y0);                                      /*  II. Quadrant */
      setPixel(x0, y1);                                      /* III. Quadrant */
      setPixel(x1, y1);                                      /*  IV. Quadrant */
      e2 = 2*err;
      if (e2 <= dy) { y0++; y1--; err += dy += a; }                 /* y step */
      if (e2 >= dx || 2*err > dy) { x0++; x1--; err += dx += b1; }  /* x step */
   } while (x0 <= x1);

   while (y0-y1 <= b) {                /* too early stop of flat ellipses a=1 */
      setPixel(x0-1, y0);                         /* -> finish tip of ellipse */
      setPixel(x1+1, y0++);
      setPixel(x0-1, y1);
      setPixel(x1+1, y1--);
   }
}

void plotQuadBezierSeg(int x0, int y0, int x1, int y1, int x2, int y2)
{                                  /* plot a limited quadratic Bezier segment */
  int sx = x2-x1, sy = y2-y1;
  long xx = x0-x1, yy = y0-y1, xy;              /* relative values for checks */
  double dx, dy, err, cur = xx*sy-yy*sx;                         /* curvature */

  assert(xx*sx <= 0 && yy*sy <= 0);       /* sign of gradient must not change */

  if (sx*(long)sx+sy*(long)sy > xx*xx+yy*yy) {      /* begin with longer part */
    x2 = x0; x0 = sx+x1; y2 = y0; y0 = sy+y1; cur = -cur;       /* swap P0 P2 */
  }
  if (cur != 0) {                                         /* no straight line */
    xx += sx; xx *= sx = x0 < x2 ? 1 : -1;                /* x step direction */
    yy += sy; yy *= sy = y0 < y2 ? 1 : -1;                /* y step direction */
    xy = 2*xx*yy; xx *= xx; yy *= yy;               /* differences 2nd degree */
    if (cur*sx*sy < 0) {                                /* negated curvature? */
      xx = -xx; yy = -yy; xy = -xy; cur = -cur;
    }
    dx = 4.0*sy*cur*(x1-x0)+xx-xy;                  /* differences 1st degree */
    dy = 4.0*sx*cur*(y0-y1)+yy-xy;
    xx += xx; yy += yy; err = dx+dy+xy;                     /* error 1st step */
    do {
      setPixel(x0,y0);                                          /* plot curve */
      if (x0 == x2 && y0 == y2) return;       /* last pixel -> curve finished */
      y1 = 2*err < dx;                       /* save value for test of y step */
      if (2*err > dy) { x0 += sx; dx -= xy; err += dy += yy; }      /* x step */
      if (    y1    ) { y0 += sy; dy -= xy; err += dx += xx; }      /* y step */
    } while (dy < 0 && dx > 0);        /* gradient negates -> algorithm fails */
  }
  plotLine(x0,y0, x2,y2);                       /* plot remaining part to end */
}

void plotQuadBezier(int x0, int y0, int x1, int y1, int x2, int y2)
{                                          /* plot any quadratic Bezier curve */
   int x = x0-x1, y = y0-y1;
   double t = x0-2*x1+x2, r;

   if ((long)x*(x2-x1) > 0) {                        /* horizontal cut at P4? */
      if ((long)y*(y2-y1) > 0)                     /* vertical cut at P6 too? */
         if (fabs((y0-2*y1+y2)/t*x) > abs(y)) {               /* which first? */
            x0 = x2; x2 = x+x1; y0 = y2; y2 = y+y1;            /* swap points */
         }                            /* now horizontal cut at P4 comes first */
      t = (x0-x1)/t;
      r = (1-t)*((1-t)*y0+2.0*t*y1)+t*t*y2;                       /* By(t=P4) */
      t = (x0*x2-x1*x1)*t/(x0-x1);                       /* gradient dP4/dx=0 */
      x = floor(t+0.5); y = floor(r+0.5);
      r = (y1-y0)*(t-x0)/(x1-x0)+y0;                  /* intersect P3 | P0 P1 */
      plotQuadBezierSeg(x0,y0, x,floor(r+0.5), x,y);
      r = (y1-y2)*(t-x2)/(x1-x2)+y2;                  /* intersect P4 | P1 P2 */
      x0 = x1 = x; y0 = y; y1 = floor(r+0.5);             /* P0 = P4, P1 = P8 */
   }
   if ((long)(y0-y1)*(y2-y1) > 0) {                    /* vertical cut at P6? */
      t = y0-2*y1+y2; t = (y0-y1)/t;
      r = (1-t)*((1-t)*x0+2.0*t*x1)+t*t*x2;                       /* Bx(t=P6) */
      t = (y0*y2-y1*y1)*t/(y0-y1);                       /* gradient dP6/dy=0 */
      x = floor(r+0.5); y = floor(t+0.5);
      r = (x1-x0)*(t-y0)/(y1-y0)+x0;                  /* intersect P6 | P0 P1 */
      plotQuadBezierSeg(x0,y0, floor(r+0.5),y, x,y);
      r = (x1-x2)*(t-y2)/(y1-y2)+x2;                  /* intersect P7 | P1 P2 */
      x0 = x; x1 = floor(r+0.5); y0 = y1 = y;             /* P0 = P6, P1 = P7 */
   }
   plotQuadBezierSeg(x0,y0, x1,y1, x2,y2);                  /* remaining part */
}

void plotQuadRationalBezierSeg(int x0, int y0, int x1, int y1,
                               int x2, int y2, float w)
{                   /* plot a limited rational Bezier segment, squared weight */
  int sx = x2-x1, sy = y2-y1;                   /* relative values for checks */
  double dx = x0-x2, dy = y0-y2, xx = x0-x1, yy = y0-y1;
  double xy = xx*sy+yy*sx, cur = xx*sy-yy*sx, err;               /* curvature */

  assert(xx*sx <= 0.0 && yy*sy <= 0.0);   /* sign of gradient must not change */

  if (cur != 0.0 && w > 0.0) {                            /* no straight line */
    if (sx*(long)sx+sy*(long)sy > xx*xx+yy*yy) {    /* begin with longer part */
      x2 = x0; x0 -= dx; y2 = y0; y0 -= dy; cur = -cur;         /* swap P0 P2 */
    }
    xx = 2.0*(4.0*w*sx*xx+dx*dx);                   /* differences 2nd degree */
    yy = 2.0*(4.0*w*sy*yy+dy*dy);
    sx = x0 < x2 ? 1 : -1;                                /* x step direction */
    sy = y0 < y2 ? 1 : -1;                                /* y step direction */
    xy = -2.0*sx*sy*(2.0*w*xy+dx*dy);

    if (cur*sx*sy < 0.0) {                              /* negated curvature? */
      xx = -xx; yy = -yy; xy = -xy; cur = -cur;
    }
    dx = 4.0*w*(x1-x0)*sy*cur+xx/2.0+xy;            /* differences 1st degree */
    dy = 4.0*w*(y0-y1)*sx*cur+yy/2.0+xy;

    if (w < 0.5 && (dy > xy || dx < xy)) {   /* flat ellipse, algorithm fails */
       cur = (w+1.0)/2.0; w = sqrt(w); xy = 1.0/(w+1.0);
       sx = floor((x0+2.0*w*x1+x2)*xy/2.0+0.5);    /* subdivide curve in half */
       sy = floor((y0+2.0*w*y1+y2)*xy/2.0+0.5);
       dx = floor((w*x1+x0)*xy+0.5); dy = floor((y1*w+y0)*xy+0.5);
       plotQuadRationalBezierSeg(x0,y0, dx,dy, sx,sy, cur);/* plot separately */
       dx = floor((w*x1+x2)*xy+0.5); dy = floor((y1*w+y2)*xy+0.5);
       plotQuadRationalBezierSeg(sx,sy, dx,dy, x2,y2, cur);
       return;
    }
    err = dx+dy-xy;                                           /* error 1.step */
    do {
      setPixel(x0,y0);                                          /* plot curve */
      if (x0 == x2 && y0 == y2) return;       /* last pixel -> curve finished */
      x1 = 2*err > dy; y1 = 2*(err+yy) < -dy;/* save value for test of x step */
      if (2*err < dx || y1) { y0 += sy; dy += xy; err += dx += xx; }/* y step */
      if (2*err > dx || x1) { x0 += sx; dx += xy; err += dy += yy; }/* x step */
    } while (dy <= xy && dx >= xy);    /* gradient negates -> algorithm fails */
  }
  plotLine(x0,y0, x2,y2);                     /* plot remaining needle to end */
}

void plotQuadRationalBezier(int x0, int y0, int x1, int y1,
                            int x2, int y2, float w)
{                                 /* plot any quadratic rational Bezier curve */
   int x = x0-2*x1+x2, y = y0-2*y1+y2;
   double xx = x0-x1, yy = y0-y1, ww, t, q;

   assert(w >= 0.0);

   if (xx*(x2-x1) > 0) {                             /* horizontal cut at P4? */
      if (yy*(y2-y1) > 0)                          /* vertical cut at P6 too? */
         if (fabs(xx*y) > fabs(yy*x)) {                       /* which first? */
            x0 = x2; x2 = xx+x1; y0 = y2; y2 = yy+y1;          /* swap points */
         }                            /* now horizontal cut at P4 comes first */
      if (x0 == x2 || w == 1.0) t = (x0-x1)/(double)x;
      else {                                 /* non-rational or rational case */
         q = sqrt(4.0*w*w*(x0-x1)*(x2-x1)+(x2-x0)*(long)(x2-x0));
         if (x1 < x0) q = -q;
         t = (2.0*w*(x0-x1)-x0+x2+q)/(2.0*(1.0-w)*(x2-x0));        /* t at P4 */
      }
      q = 1.0/(2.0*t*(1.0-t)*(w-1.0)+1.0);                 /* sub-divide at t */
      xx = (t*t*(x0-2.0*w*x1+x2)+2.0*t*(w*x1-x0)+x0)*q;               /* = P4 */
      yy = (t*t*(y0-2.0*w*y1+y2)+2.0*t*(w*y1-y0)+y0)*q;
      ww = t*(w-1.0)+1.0; ww *= ww*q;                    /* squared weight P3 */
      w = ((1.0-t)*(w-1.0)+1.0)*sqrt(q);                         /* weight P8 */
      x = floor(xx+0.5); y = floor(yy+0.5);                             /* P4 */
      yy = (xx-x0)*(y1-y0)/(x1-x0)+y0;                /* intersect P3 | P0 P1 */
      plotQuadRationalBezierSeg(x0,y0, x,floor(yy+0.5), x,y, ww);
      yy = (xx-x2)*(y1-y2)/(x1-x2)+y2;                /* intersect P4 | P1 P2 */
      y1 = floor(yy+0.5); x0 = x1 = x; y0 = y;            /* P0 = P4, P1 = P8 */
   }
   if ((y0-y1)*(long)(y2-y1) > 0) {                    /* vertical cut at P6? */
      if (y0 == y2 || w == 1.0) t = (y0-y1)/(y0-2.0*y1+y2);
      else {                                 /* non-rational or rational case */
         q = sqrt(4.0*w*w*(y0-y1)*(y2-y1)+(y2-y0)*(long)(y2-y0));
         if (y1 < y0) q = -q;
         t = (2.0*w*(y0-y1)-y0+y2+q)/(2.0*(1.0-w)*(y2-y0));        /* t at P6 */
      }
      q = 1.0/(2.0*t*(1.0-t)*(w-1.0)+1.0);                 /* sub-divide at t */
      xx = (t*t*(x0-2.0*w*x1+x2)+2.0*t*(w*x1-x0)+x0)*q;               /* = P6 */
      yy = (t*t*(y0-2.0*w*y1+y2)+2.0*t*(w*y1-y0)+y0)*q;
      ww = t*(w-1.0)+1.0; ww *= ww*q;                    /* squared weight P5 */
      w = ((1.0-t)*(w-1.0)+1.0)*sqrt(q);                         /* weight P7 */
      x = floor(xx+0.5); y = floor(yy+0.5);                             /* P6 */
      xx = (x1-x0)*(yy-y0)/(y1-y0)+x0;                /* intersect P6 | P0 P1 */
      plotQuadRationalBezierSeg(x0,y0, floor(xx+0.5),y, x,y, ww);
      xx = (x1-x2)*(yy-y2)/(y1-y2)+x2;                /* intersect P7 | P1 P2 */
      x1 = floor(xx+0.5); x0 = x; y0 = y1 = y;            /* P0 = P6, P1 = P7 */
   }
   plotQuadRationalBezierSeg(x0,y0, x1,y1, x2,y2, w*w);          /* remaining */
}

void plotRotatedEllipse(int x, int y, int a, int b, float angle)
{                                   /* plot ellipse rotated by angle (radian) */
   float xd = (long)a*a, yd = (long)b*b;
   float s = sin(angle), zd = (xd-yd)*s;                  /* ellipse rotation */
   xd = sqrt(xd-zd*s), yd = sqrt(yd+zd*s);           /* surrounding rectangle */
   a = xd+0.5; b = yd+0.5; zd = zd*a*b/(xd*yd);           /* scale to integer */
   plotRotatedEllipseRect(x-a,y-b, x+a,y+b, (long)(4*zd*cos(angle)));
}

void plotRotatedEllipseRect(int x0, int y0, int x1, int y1, long zd)
{                  /* rectangle enclosing the ellipse, integer rotation angle */
   int xd = x1-x0, yd = y1-y0;
   float w = xd*(long)yd;
   if (zd == 0) return plotEllipseRect(x0,y0, x1,y1);          /* looks nicer */
   if (w != 0.0) w = (w-zd)/(w+w);                    /* squared weight of P1 */
   assert(w <= 1.0 && w >= 0.0);                /* limit angle to |zd|<=xd*yd */
   xd = floor(xd*w+0.5); yd = floor(yd*w+0.5);           /* snap xe,ye to int */
   plotQuadRationalBezierSeg(x0,y0+yd, x0,y0, x0+xd,y0, 1.0-w);
   plotQuadRationalBezierSeg(x0,y0+yd, x0,y1, x1-xd,y1, w);
   plotQuadRationalBezierSeg(x1,y1-yd, x1,y1, x1-xd,y1, 1.0-w);
   plotQuadRationalBezierSeg(x1,y1-yd, x1,y0, x0+xd,y0, w);
}

void plotCubicBezierSeg(int x0, int y0, float x1, float y1,
                        float x2, float y2, int x3, int y3)
{                                        /* plot limited cubic Bezier segment */
   int f, fx, fy, leg = 1;
   int sx = x0 < x3 ? 1 : -1, sy = y0 < y3 ? 1 : -1;        /* step direction */
   float xc = -fabs(x0+x1-x2-x3), xa = xc-4*sx*(x1-x2), xb = sx*(x0-x1-x2+x3);
   float yc = -fabs(y0+y1-y2-y3), ya = yc-4*sy*(y1-y2), yb = sy*(y0-y1-y2+y3);
   double ab, ac, bc, cb, xx, xy, yy, dx, dy, ex, *pxy, EP = 0.01;
                                                 /* check for curve restrains */
   /* slope P0-P1 == P2-P3    and  (P0-P3 == P1-P2      or   no slope change) */
   assert((x1-x0)*(x2-x3) < EP && ((x3-x0)*(x1-x2) < EP || xb*xb < xa*xc+EP));
   assert((y1-y0)*(y2-y3) < EP && ((y3-y0)*(y1-y2) < EP || yb*yb < ya*yc+EP));

   if (xa == 0 && ya == 0) {                              /* quadratic Bezier */
      sx = floor((3*x1-x0+1)/2); sy = floor((3*y1-y0+1)/2);   /* new midpoint */
      return plotQuadBezierSeg(x0,y0, sx,sy, x3,y3);
   }
   x1 = (x1-x0)*(x1-x0)+(y1-y0)*(y1-y0)+1;                    /* line lengths */
   x2 = (x2-x3)*(x2-x3)+(y2-y3)*(y2-y3)+1;
   do {                                                /* loop over both ends */
      ab = xa*yb-xb*ya; ac = xa*yc-xc*ya; bc = xb*yc-xc*yb;
      ex = ab*(ab+ac-3*bc)+ac*ac;       /* P0 part of self-intersection loop? */
      f = ex > 0 ? 1 : sqrt(1+1024/x1);               /* calculate resolution */
      ab *= f; ac *= f; bc *= f; ex *= f*f;            /* increase resolution */
      xy = 9*(ab+ac+bc)/8; cb = 8*(xa-ya);  /* init differences of 1st degree */
      dx = 27*(8*ab*(yb*yb-ya*yc)+ex*(ya+2*yb+yc))/64-ya*ya*(xy-ya);
      dy = 27*(8*ab*(xb*xb-xa*xc)-ex*(xa+2*xb+xc))/64-xa*xa*(xy+xa);
                                            /* init differences of 2nd degree */
      xx = 3*(3*ab*(3*yb*yb-ya*ya-2*ya*yc)-ya*(3*ac*(ya+yb)+ya*cb))/4;
      yy = 3*(3*ab*(3*xb*xb-xa*xa-2*xa*xc)-xa*(3*ac*(xa+xb)+xa*cb))/4;
      xy = xa*ya*(6*ab+6*ac-3*bc+cb); ac = ya*ya; cb = xa*xa;
      xy = 3*(xy+9*f*(cb*yb*yc-xb*xc*ac)-18*xb*yb*ab)/8;

      if (ex < 0) {         /* negate values if inside self-intersection loop */
         dx = -dx; dy = -dy; xx = -xx; yy = -yy; xy = -xy; ac = -ac; cb = -cb;
      }                                     /* init differences of 3rd degree */
      ab = 6*ya*ac; ac = -6*xa*ac; bc = 6*ya*cb; cb = -6*xa*cb;
      dx += xy; ex = dx+dy; dy += xy;                    /* error of 1st step */

      for (pxy = &xy, fx = fy = f; x0 != x3 && y0 != y3; ) {
         setPixel(x0,y0);                                       /* plot curve */
         do {                                  /* move sub-steps of one pixel */
            if (dx > *pxy || dy < *pxy) goto exit;       /* confusing values */
            y1 = 2*ex-dy;                    /* save value for test of y step */
            if (2*ex >= dx) {                                   /* x sub-step */
               fx--; ex += dx += xx; dy += xy += ac; yy += bc; xx += ab;
            }
            if (y1 <= 0) {                                      /* y sub-step */
               fy--; ex += dy += yy; dx += xy += bc; xx += ac; yy += cb;
            }
         } while (fx > 0 && fy > 0);                       /* pixel complete? */
         if (2*fx <= f) { x0 += sx; fx += f; }                      /* x step */
         if (2*fy <= f) { y0 += sy; fy += f; }                      /* y step */
         if (pxy == &xy && dx < 0 && dy > 0) pxy = &EP;  /* pixel ahead valid */
      }
exit: xx = x0; x0 = x3; x3 = xx; sx = -sx; xb = -xb;             /* swap legs */
      yy = y0; y0 = y3; y3 = yy; sy = -sy; yb = -yb; x1 = x2;
   } while (leg--);                                          /* try other end */
   plotLine(x0,y0, x3,y3);       /* remaining part in case of cusp or crunode */
}

void plotCubicBezier(int x0, int y0, int x1, int y1,
                     int x2, int y2, int x3, int y3)
{                                              /* plot any cubic Bezier curve */
   int n = 0, i = 0;
   long xc = x0+x1-x2-x3, xa = xc-4*(x1-x2);
   long xb = x0-x1-x2+x3, xd = xb+4*(x1+x2);
   long yc = y0+y1-y2-y3, ya = yc-4*(y1-y2);
   long yb = y0-y1-y2+y3, yd = yb+4*(y1+y2);
   float fx0 = x0, fx1, fx2, fx3, fy0 = y0, fy1, fy2, fy3;
   double t1 = xb*xb-xa*xc, t2, t[5];
                                 /* sub-divide curve at gradient sign changes */
   if (xa == 0) {                                               /* horizontal */
      if (abs(xc) < 2*abs(xb)) t[n++] = xc/(2.0*xb);            /* one change */
   } else if (t1 > 0.0) {                                      /* two changes */
      t2 = sqrt(t1);
      t1 = (xb-t2)/xa; if (fabs(t1) < 1.0) t[n++] = t1;
      t1 = (xb+t2)/xa; if (fabs(t1) < 1.0) t[n++] = t1;
   }
   t1 = yb*yb-ya*yc;
   if (ya == 0) {                                                 /* vertical */
      if (abs(yc) < 2*abs(yb)) t[n++] = yc/(2.0*yb);            /* one change */
   } else if (t1 > 0.0) {                                      /* two changes */
      t2 = sqrt(t1);
      t1 = (yb-t2)/ya; if (fabs(t1) < 1.0) t[n++] = t1;
      t1 = (yb+t2)/ya; if (fabs(t1) < 1.0) t[n++] = t1;
   }
   for (i = 1; i < n; i++)                         /* bubble sort of 4 points */
      if ((t1 = t[i-1]) > t[i]) { t[i-1] = t[i]; t[i] = t1; i = 0; }

   t1 = -1.0; t[n] = 1.0;                                /* begin / end point */
   for (i = 0; i <= n; i++) {                 /* plot each segment separately */
      t2 = t[i];                                /* sub-divide at t[i-1], t[i] */
      fx1 = (t1*(t1*xb-2*xc)-t2*(t1*(t1*xa-2*xb)+xc)+xd)/8-fx0;
      fy1 = (t1*(t1*yb-2*yc)-t2*(t1*(t1*ya-2*yb)+yc)+yd)/8-fy0;
      fx2 = (t2*(t2*xb-2*xc)-t1*(t2*(t2*xa-2*xb)+xc)+xd)/8-fx0;
      fy2 = (t2*(t2*yb-2*yc)-t1*(t2*(t2*ya-2*yb)+yc)+yd)/8-fy0;
      fx0 -= fx3 = (t2*(t2*(3*xb-t2*xa)-3*xc)+xd)/8;
      fy0 -= fy3 = (t2*(t2*(3*yb-t2*ya)-3*yc)+yd)/8;
      x3 = floor(fx3+0.5); y3 = floor(fy3+0.5);        /* scale bounds to int */
      if (fx0 != 0.0) { fx1 *= fx0 = (x0-x3)/fx0; fx2 *= fx0; }
      if (fy0 != 0.0) { fy1 *= fy0 = (y0-y3)/fy0; fy2 *= fy0; }
      if (x0 != x3 || y0 != y3)                            /* segment t1 - t2 */
         plotCubicBezierSeg(x0,y0, x0+fx1,y0+fy1, x0+fx2,y0+fy2, x3,y3);
      x0 = x3; y0 = y3; fx0 = fx3; fy0 = fy3; t1 = t2;
   }
}

void plotLineAA(int x0, int y0, int x1, int y1)
{             /* draw a black (0) anti-aliased line on white (255) background */
   int sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1, x2;
   long dx = abs(x1-x0), dy = abs(y1-y0), err = dx*dx+dy*dy;
   long e2 = err == 0 ? 1 : 0xffff7fl/sqrt(err);     /* multiplication factor */

   dx *= e2; dy *= e2; err = dx-dy;                       /* error value e_xy */
   for ( ; ; ){                                                 /* pixel loop */
      setPixelAA(x0,y0,abs(err-dx+dy)>>16);
      e2 = err; x2 = x0;
      if (2*e2 >= -dx) {                                            /* x step */
         if (x0 == x1) break;
         if (e2+dy < 0xff0000l) setPixelAA(x0,y0+sy,(e2+dy)>>16);
         err -= dy; x0 += sx;
      }
      if (2*e2 <= dy) {                                             /* y step */
         if (y0 == y1) break;
         if (dx-e2 < 0xff0000l) setPixelAA(x2+sx,y0,(dx-e2)>>16);
         err += dx; y0 += sy;
    }
}

void plotCircleAA(int xm, int ym, int r)
{                     /* draw a black anti-aliased circle on white background */
   int x = -r, y = 0;           /* II. quadrant from bottom left to top right */
   int i, x2, e2, err = 2-2*r;                             /* error of 1.step */
   r = 1-err;
   do {
      i = 255*abs(err-2*(x+y)-2)/r;               /* get blend value of pixel */
      setPixelAA(xm-x, ym+y, i);                             /*   I. Quadrant */
      setPixelAA(xm-y, ym-x, i);                             /*  II. Quadrant */
      setPixelAA(xm+x, ym-y, i);                             /* III. Quadrant */
      setPixelAA(xm+y, ym+x, i);                             /*  IV. Quadrant */
      e2 = err; x2 = x;                                    /* remember values */
      if (err+y > 0) {                                              /* x step */
         i = 255*(err-2*x-1)/r;                              /* outward pixel */
         if (i < 256) {
            setPixelAA(xm-x, ym+y+1, i);
            setPixelAA(xm-y-1, ym-x, i);
            setPixelAA(xm+x, ym-y-1, i);
            setPixelAA(xm+y+1, ym+x, i);
         }
         err += ++x*2+1;
      }
      if (e2+x2 <= 0) {                                             /* y step */
         i = 255*(2*y+3-e2)/r;                                /* inward pixel */
         if (i < 256) {
            setPixelAA(xm-x2-1, ym+y, i);
            setPixelAA(xm-y, ym-x2-1, i);
            setPixelAA(xm+x2+1, ym-y, i);
            setPixelAA(xm+y, ym+x2+1, i);
         }
         err += ++y*2+1;
      }
   } while (x < 0);
}

void plotEllipseRectAA(int x0, int y0, int x1, int y1)
{        /* draw a black anti-aliased rectangular ellipse on white background */
   long a = abs(x1-x0), b = abs(y1-y0), b1 = b&1;                 /* diameter */
   float dx = 4*(a-1.0)*b*b, dy = 4*(b1+1)*a*a;            /* error increment */
   float ed, i, err = b1*a*a-dx+dy;                        /* error of 1.step */
   bool f;

   if (a == 0 || b == 0) return plotLine(x0,y0, x1,y1);
   if (x0 > x1) { x0 = x1; x1 += a; }        /* if called with swapped points */
   if (y0 > y1) y0 = y1;                                  /* .. exchange them */
   y0 += (b+1)/2; y1 = y0-b1;                               /* starting pixel */
   a = 8*a*a; b1 = 8*b*b;

   for (;;) {                             /* approximate ed=sqrt(dx*dx+dy*dy) */
      i = min(dx,dy); ed = max(dx,dy);
      if (y0 == y1+1 && err > dy && a > b1) ed = 255*4./a;           /* x-tip */
      else ed = 255/(ed+2*ed*i*i/(4*ed*ed+i*i));             /* approximation */
      i = ed*fabs(err+dx-dy);           /* get intensity value by pixel error */
      setPixelAA(x0,y0, i); setPixelAA(x0,y1, i);
      setPixelAA(x1,y0, i); setPixelAA(x1,y1, i);

      if (f = 2*err+dy >= 0) {                  /* x step, remember condition */
         if (x0 >= x1) break;
         i = ed*(err+dx);
         if (i < 255) {
            setPixelAA(x0,y0+1, i); setPixelAA(x0,y1-1, i);
            setPixelAA(x1,y0+1, i); setPixelAA(x1,y1-1, i);
         }          /* do error increment later since values are still needed */
      }
      if (2*err <= dx) {                                            /* y step */
         i = ed*(dy-err);
         if (i < 255) {
            setPixelAA(x0+1,y0, i); setPixelAA(x1-1,y0, i);
            setPixelAA(x0+1,y1, i); setPixelAA(x1-1,y1, i);
         }
         y0++; y1--; err += dy += a;
      }
      if (f) { x0++; x1--; err -= dx -= b1; }            /* x error increment */
   }
   if (--x0 == x1++)                       /* too early stop of flat ellipses */
      while (y0-y1 < b) {
         i = 255*4*fabs(err+dx)/b1;               /* -> finish tip of ellipse */
         setPixelAA(x0,++y0, i); setPixelAA(x1,y0, i);
         setPixelAA(x0,--y1, i); setPixelAA(x1,y1, i);
         err += dy += a;
      }
}

void plotQuadBezierSegAA(int x0, int y0, int x1, int y1, int x2, int y2)
{                    /* draw an limited anti-aliased quadratic Bezier segment */
   int sx = x2-x1, sy = y2-y1;
   long xx = x0-x1, yy = y0-y1, xy;             /* relative values for checks */
   double dx, dy, err, ed, cur = xx*sy-yy*sx;                    /* curvature */

   assert(xx*sx <= 0 && yy*sy <= 0);      /* sign of gradient must not change */

   if (sx*(long)sx+sy*(long)sy > xx*xx+yy*yy) {     /* begin with longer part */
      x2 = x0; x0 = sx+x1; y2 = y0; y0 = sy+y1; cur = -cur;     /* swap P0 P2 */
   }
   if (cur != 0)
   {                                                      /* no straight line */
      xx += sx; xx *= sx = x0 < x2 ? 1 : -1;              /* x step direction */
      yy += sy; yy *= sy = y0 < y2 ? 1 : -1;              /* y step direction */
      xy = 2*xx*yy; xx *= xx; yy *= yy;             /* differences 2nd degree */
      if (cur*sx*sy < 0) {                              /* negated curvature? */
         xx = -xx; yy = -yy; xy = -xy; cur = -cur;
      }
      dx = 4.0*sy*(x1-x0)*cur+xx-xy;                /* differences 1st degree */
      dy = 4.0*sx*(y0-y1)*cur+yy-xy;
      xx += xx; yy += yy; err = dx+dy+xy;                   /* error 1st step */
      do {
         cur = fmin(dx+xy,-xy-dy);
         ed = fmax(dx+xy,-xy-dy);               /* approximate error distance */
         ed += 2*ed*cur*cur/(4*ed*ed+cur*cur);
         setPixelAA(x0,y0, 255*fabs(err-dx-dy-xy)/ed);          /* plot curve */
         if (x0 == x2 || y0 == y2) break;     /* last pixel -> curve finished */
         x1 = x0; cur = dx-err; y1 = 2*err+dy < 0;
         if (2*err+dx > 0) {                                        /* x step */
            if (err-dy < ed) setPixelAA(x0,y0+sy, 255*fabs(err-dy)/ed);
            x0 += sx; dx -= xy; err += dy += yy;
         }
         if (y1) {                                                  /* y step */
            if (cur < ed) setPixelAA(x1+sx,y0, 255*fabs(cur)/ed);
            y0 += sy; dy -= xy; err += dx += xx;
         }
      } while (dy < dx);                  /* gradient negates -> close curves */
   }
   plotLineAA(x0,y0, x2,y2);                  /* plot remaining needle to end */
}

void plotQuadRationalBezierSegAA(int x0, int y0, int x1, int y1,
                                 int x2, int y2, float w)
{   /* draw an anti-aliased rational quadratic Bezier segment, squared weight */
   int sx = x2-x1, sy = y2-y1;                  /* relative values for checks */
   double dx = x0-x2, dy = y0-y2, xx = x0-x1, yy = y0-y1;
   double xy = xx*sy+yy*sx, cur = xx*sy-yy*sx, err, ed;          /* curvature */
   bool f;

   assert(xx*sx <= 0.0 && yy*sy <= 0.0);  /* sign of gradient must not change */

   if (cur != 0.0 && w > 0.0) {                           /* no straight line */
      if (sx*(long)sx+sy*(long)sy > xx*xx+yy*yy) {  /* begin with longer part */
         x2 = x0; x0 -= dx; y2 = y0; y0 -= dy; cur = -cur;      /* swap P0 P2 */
      }
      xx = 2.0*(4.0*w*sx*xx+dx*dx);                 /* differences 2nd degree */
      yy = 2.0*(4.0*w*sy*yy+dy*dy);
      sx = x0 < x2 ? 1 : -1;                              /* x step direction */
      sy = y0 < y2 ? 1 : -1;                              /* y step direction */
      xy = -2.0*sx*sy*(2.0*w*xy+dx*dy);

      if (cur*sx*sy < 0) {                              /* negated curvature? */
         xx = -xx; yy = -yy; cur = -cur; xy = -xy;
      }
      dx = 4.0*w*(x1-x0)*sy*cur+xx/2.0+xy;          /* differences 1st degree */
      dy = 4.0*w*(y0-y1)*sx*cur+yy/2.0+xy;

      if (w < 0.5 && dy > dx) {              /* flat ellipse, algorithm fails */
         cur = (w+1.0)/2.0; w = sqrt(w); xy = 1.0/(w+1.0);
         sx = floor((x0+2.0*w*x1+x2)*xy/2.0+0.5); /* subdivide curve in half  */
         sy = floor((y0+2.0*w*y1+y2)*xy/2.0+0.5);
         dx = floor((w*x1+x0)*xy+0.5); dy = floor((y1*w+y0)*xy+0.5);
         plotQuadRationalBezierSegAA(x0,y0, dx,dy, sx,sy, cur); /* plot apart */
         dx = floor((w*x1+x2)*xy+0.5); dy = floor((y1*w+y2)*xy+0.5);
         return plotQuadRationalBezierSegAA(sx,sy, dx,dy, x2,y2, cur);
      }
      err = dx+dy-xy;                                       /* error 1st step */
      do {                                                      /* pixel loop */
         cur = fmin(dx-xy,xy-dy); ed = fmax(dx-xy,xy-dy);
         ed += 2*ed*cur*cur/(4.*ed*ed+cur*cur); /* approximate error distance */
         x1 = 255*fabs(err-dx-dy+xy)/ed;    /* get blend value by pixel error */
         if (x1 < 256) setPixelAA(x0,y0, x1);                   /* plot curve */
         if (f = 2*err+dy < 0) {                                    /* y step */
            if (y0 == y2) return;             /* last pixel -> curve finished */
            if (dx-err < ed) setPixelAA(x0+sx,y0, 255*fabs(dx-err)/ed);
         }
         if (2*err+dx > 0) {                                        /* x step */
            if (x0 == x2) return;             /* last pixel -> curve finished */
            if (err-dy < ed) setPixelAA(x0,y0+sy, 255*fabs(err-dy)/ed);
            x0 += sx; dx += xy; err += dy += yy;
         }
         if (f) { y0 += sy; dy += xy; err += dx += xx; }            /* y step */
      } while (dy < dx);               /* gradient negates -> algorithm fails */
   }
   plotLineAA(x0,y0, x2,y2);                  /* plot remaining needle to end */
}

void plotCubicBezierSegAA(int x0, int y0, float x1, float y1,
                          float x2, float y2, int x3, int y3)
{                           /* plot limited anti-aliased cubic Bezier segment */
   int f, fx, fy, leg = 1;
   int sx = x0 < x3 ? 1 : -1, sy = y0 < y3 ? 1 : -1;        /* step direction */
   float xc = -fabs(x0+x1-x2-x3), xa = xc-4*sx*(x1-x2), xb = sx*(x0-x1-x2+x3);
   float yc = -fabs(y0+y1-y2-y3), ya = yc-4*sy*(y1-y2), yb = sy*(y0-y1-y2+y3);
   double ab, ac, bc, ba, xx, xy, yy, dx, dy, ex, px, py, ed, ip, EP = 0.01;

                                                 /* check for curve restrains */
   /* slope P0-P1 == P2-P3     and  (P0-P3 == P1-P2      or  no slope change) */
   assert((x1-x0)*(x2-x3) < EP && ((x3-x0)*(x1-x2) < EP || xb*xb < xa*xc+EP));
   assert((y1-y0)*(y2-y3) < EP && ((y3-y0)*(y1-y2) < EP || yb*yb < ya*yc+EP));

   if (xa == 0 && ya == 0) {                              /* quadratic Bezier */
      sx = floor((3*x1-x0+1)/2); sy = floor((3*y1-y0+1)/2);   /* new midpoint */
      return plotQuadBezierSegAA(x0,y0, sx,sy, x3,y3);
   }
   x1 = (x1-x0)*(x1-x0)+(y1-y0)*(y1-y0)+1;                    /* line lengths */
   x2 = (x2-x3)*(x2-x3)+(y2-y3)*(y2-y3)+1;
   do {                                                /* loop over both ends */
      ab = xa*yb-xb*ya; ac = xa*yc-xc*ya; bc = xb*yc-xc*yb;
      ip = 4*ab*bc-ac*ac;                   /* self intersection loop at all? */
      ex = ab*(ab+ac-3*bc)+ac*ac;       /* P0 part of self-intersection loop? */
      f = ex > 0 ? 1 : sqrt(1+1024/x1);               /* calculate resolution */
      ab *= f; ac *= f; bc *= f; ex *= f*f;            /* increase resolution */
      xy = 9*(ab+ac+bc)/8; ba = 8*(xa-ya);  /* init differences of 1st degree */
      dx = 27*(8*ab*(yb*yb-ya*yc)+ex*(ya+2*yb+yc))/64-ya*ya*(xy-ya);
      dy = 27*(8*ab*(xb*xb-xa*xc)-ex*(xa+2*xb+xc))/64-xa*xa*(xy+xa);
                                            /* init differences of 2nd degree */
      xx = 3*(3*ab*(3*yb*yb-ya*ya-2*ya*yc)-ya*(3*ac*(ya+yb)+ya*ba))/4;
      yy = 3*(3*ab*(3*xb*xb-xa*xa-2*xa*xc)-xa*(3*ac*(xa+xb)+xa*ba))/4;
      xy = xa*ya*(6*ab+6*ac-3*bc+ba); ac = ya*ya; ba = xa*xa;
      xy = 3*(xy+9*f*(ba*yb*yc-xb*xc*ac)-18*xb*yb*ab)/8;

      if (ex < 0) {         /* negate values if inside self-intersection loop */
         dx = -dx; dy = -dy; xx = -xx; yy = -yy; xy = -xy; ac = -ac; ba = -ba;
      }                                     /* init differences of 3rd degree */
      ab = 6*ya*ac; ac = -6*xa*ac; bc = 6*ya*ba; ba = -6*xa*ba;
      dx += xy; ex = dx+dy; dy += xy;                    /* error of 1st step */

      for (fx = fy = f; x0 != x3 && y0 != y3; ) {
         y1 = fmin(fabs(xy-dx),fabs(dy-xy));
         ed = fmax(fabs(xy-dx),fabs(dy-xy));    /* approximate error distance */
         ed = f*(ed+2*ed*y1*y1/(4*ed*ed+y1*y1));
         y1 = 255*fabs(ex-(f-fx+1)*dx-(f-fy+1)*dy+f*xy)/ed;
         if (y1 < 256) setPixelAA(x0, y0, y1);                  /* plot curve */
         px = fabs(ex-(f-fx+1)*dx+(fy-1)*dy);       /* pixel intensity x move */
         py = fabs(ex+(fx-1)*dx-(f-fy+1)*dy);       /* pixel intensity y move */
         y2 = y0;
         do {                                  /* move sub-steps of one pixel */
            if (ip >= -EP)               /* intersection possible? -> check.. */
               if (dx+xx > xy || dy+yy < xy) goto exit;   /* two x or y steps */
            y1 = 2*ex+dx;                    /* save value for test of y step */
            if (2*ex+dy > 0) {                                  /* x sub-step */
               fx--; ex += dx += xx; dy += xy += ac; yy += bc; xx += ab;
            } else if (y1 > 0) goto exit;                 /* tiny nearly cusp */
            if (y1 <= 0) {                                      /* y sub-step */
               fy--; ex += dy += yy; dx += xy += bc; xx += ac; yy += ba;
            }
         } while (fx > 0 && fy > 0);                       /* pixel complete? */
         if (2*fy <= f) {                           /* x+ anti-aliasing pixel */
            if (py < ed) setPixelAA(x0+sx, y0, 255*py/ed);      /* plot curve */
            y0 += sy; fy += f;                                      /* y step */
         }
         if (2*fx <= f) {                           /* y+ anti-aliasing pixel */
            if (px < ed) setPixelAA(x0, y2+sy, 255*px/ed);      /* plot curve */
            x0 += sx; fx += f;                                      /* x step */
         }
      }
      break;                                          /* finish curve by line */
exit:
      if (2*ex < dy && 2*fy <= f+2) {         /* round x+ approximation pixel */
         if (py < ed) setPixelAA(x0+sx, y0, 255*py/ed);         /* plot curve */
         y0 += sy;
      }
      if (2*ex > dx && 2*fx <= f+2) {         /* round y+ approximation pixel */
         if (px < ed) setPixelAA(x0, y2+sy, 255*px/ed);         /* plot curve */
         x0 += sx;
      }
      xx = x0; x0 = x3; x3 = xx; sx = -sx; xb = -xb;             /* swap legs */
      yy = y0; y0 = y3; y3 = yy; sy = -sy; yb = -yb; x1 = x2;
   } while (leg--);                                          /* try other end */
   plotLineAA(x0,y0, x3,y3);     /* remaining part in case of cusp or crunode */
}

void plotLineWidth(int x0, int y0, int x1, int y1, float wd)
{                                    /* plot an anti-aliased line of width wd */
   int dx = abs(x1-x0), sx = x0 < x1 ? 1 : -1;
   int dy = abs(y1-y0), sy = y0 < y1 ? 1 : -1;
   int err = dx-dy, e2, x2, y2;                           /* error value e_xy */
   float ed = dx+dy == 0 ? 1 : sqrt((float)dx*dx+(float)dy*dy);

   for (wd = (wd+1)/2; ; ) {                                    /* pixel loop */
      setPixelColor(x0, y0, max(0,255*(abs(err-dx+dy)/ed-wd+1)));
      e2 = err; x2 = x0;
      if (2*e2 >= -dx) {                                            /* x step */
         for (e2 += dy, y2 = y0; e2 < ed*wd && (y1 != y2 || dx > dy); e2 += dx)
            setPixelColor(x0, y2 += sy, max(0,255*(abs(e2)/ed-wd+1)));
         if (x0 == x1) break;
         e2 = err; err -= dy; x0 += sx;
      }
      if (2*e2 <= dy) {                                             /* y step */
         for (e2 = dx-e2; e2 < ed*wd && (x1 != x2 || dx < dy); e2 += dy)
            setPixelColor(x2 += sx, y0, max(0,255*(abs(e2)/ed-wd+1)));
         if (y0 == y1) break;
         err += dx; y0 += sy;
      }
   }
}

void plotQuadSpline(int n, int x[], int y[])
{                         /* plot quadratic spline, destroys input arrays x,y */
   #define M_MAX 6
   float mi = 1, m[M_MAX];                    /* diagonal constants of matrix */
   int i, x0, y0, x1, y1, x2 = x[n], y2 = y[n];

   assert(n > 1);                        /* need at least 3 points P[0]..P[n] */

   x[1] = x0 = 8*x[1]-2*x[0];                          /* first row of matrix */
   y[1] = y0 = 8*y[1]-2*y[0];

   for (i = 2; i < n; i++) {                                 /* forward sweep */
      if (i-2 < M_MAX) m[i-2] = mi = 1.0/(6.0-mi);
      x[i] = x0 = floor(8*x[i]-x0*mi+0.5);                        /* store yi */
      y[i] = y0 = floor(8*y[i]-y0*mi+0.5);
   }
   x1 = floor((x0-2*x2)/(5.0-mi)+0.5);                 /* correction last row */
   y1 = floor((y0-2*y2)/(5.0-mi)+0.5);

   for (i = n-2; i > 0; i--) {                           /* back substitution */
      if (i <= M_MAX) mi = m[i-1];
      x0 = floor((x[i]-x1)*mi+0.5);                            /* next corner */
      y0 = floor((y[i]-y1)*mi+0.5);
      plotQuadBezier((x0+x1)/2,(y0+y1)/2, x1,y1, x2,y2);
      x2 = (x0+x1)/2; x1 = x0;
      y2 = (y0+y1)/2; y1 = y0;
   }
   plotQuadBezier(x[0],y[0], x1,y1, x2,y2);
}

void plotCubicSpline(int n, int x[], int y[])
{                             /* plot cubic spline, destroys input arrays x,y */
   #define M_MAX 6
   float mi = 0.25, m[M_MAX];                 /* diagonal constants of matrix */
   int x3 = x[n-1], y3 = y[n-1], x4 = x[n], y4 = y[n];
   int i, x0, y0, x1, y1, x2, y2;

   assert(n > 2);                        /* need at least 4 points P[0]..P[n] */

   x[1] = x0 = 12*x[1]-3*x[0];                         /* first row of matrix */
   y[1] = y0 = 12*y[1]-3*y[0];

   for (i = 2; i < n; i++) {                                /* foreward sweep */
      if (i-2 < M_MAX) m[i-2] = mi = 0.25/(2.0-mi);
      x[i] = x0 = floor(12*x[i]-2*x0*mi+0.5);
      y[i] = y0 = floor(12*y[i]-2*y0*mi+0.5);
   }
   x2 = floor((x0-3*x4)/(7-4*mi)+0.5);                    /* correct last row */
   y2 = floor((y0-3*y4)/(7-4*mi)+0.5);
   plotCubicBezier(x3,y3, (x2+x4)/2,(y2+y4)/2, x4,y4, x4,y4);

   if (n-3 < M_MAX) mi = m[n-3];
   x1 = floor((x[n-2]-2*x2)*mi+0.5);
   y1 = floor((y[n-2]-2*y2)*mi+0.5);
   for (i = n-3; i > 0; i--) {                           /* back substitution */
      if (i <= M_MAX) mi = m[i-1];
      x0 = floor((x[i]-2*x1)*mi+0.5);
      y0 = floor((y[i]-2*y1)*mi+0.5);
      x4 = floor((x0+4*x1+x2+3)/6.0);                     /* reconstruct P[i] */
      y4 = floor((y0+4*y1+y2+3)/6.0);
      plotCubicBezier(x4,y4,
                      floor((2*x1+x2)/3+0.5),floor((2*y1+y2)/3+0.5),
                      floor((x1+2*x2)/3+0.5),floor((y1+2*y2)/3+0.5),
                      x3,y3);
      x3 = x4; y3 = y4; x2 = x1; y2 = y1; x1 = x0; y1 = y0;
   }
   x0 = x[0]; x4 = floor((3*x0+7*x1+2*x2+6)/12.0);        /* reconstruct P[1] */
   y0 = y[0]; y4 = floor((3*y0+7*y1+2*y2+6)/12.0);
   plotCubicBezier(x4,y4, floor((2*x1+x2)/3+0.5),floor((2*y1+y2)/3+0.5),
                   floor((x1+2*x2)/3+0.5),floor((y1+2*y2)/3+0.5), x3,y3);
   plotCubicBezier(x0,y0, x0,y0, (x0+x1)/2,(y0+y1)/2, x4,y4);
}

FM17550读不到身份证UID的问题

Fri, 16 Oct 2020 10:25:07 +0000

项目需要读身份证UID，用的是复旦微FM17550芯片，这款芯片封装是QFN32，管脚兼容RC522、SI522。 RC522只支持ISO/IEC-14443-A类卡片， FM17550同时支持A类和B类，身份证是ISO/IEC-14443-B类卡片。

软件驱动用的是复亘微官方提供的DEMO程序，该程序是基于STM32F103平台。简单更换GPIO和SPI接口后，移植到STM32F429平台。测试能读到A类卡的UID，但刷身份证没有反应，ReaderB_Request返回244(FM175XX_TIMER_ERR)，表示请求超时。

经过一番摸索后，修改JREG_GSN和JREG_MODGSP寄存器解决问题。初始化B类接收器的代码如下：


void FM175XX_Initial_ReaderB(void)
{
	ModifyReg(JREG_STATUS2,BIT3,RESET);
	SetReg(JREG_TXMODE,BIT7|BIT1|BIT0);//BIT1~0 = 11 :ISO/IEC 14443B
	SetReg(JREG_RXMODE,BIT7|BIT1|BIT0);//BIT1~0 = 11 :ISO/IEC 14443B
	SetReg(JREG_TXAUTO,0);
	SetReg(JREG_MODWIDTH,0x26);
	SetReg(JREG_RXTRESHOLD,0x55);
	SetReg(JREG_GSN,0xF8);  //低4位值越小，调制度越深，原值是0xF8未修改。
	SetReg(JREG_CWGSP,0x3F);
	SetReg(JREG_MODGSP,0x08); //低6位值越小，调制度越深。原值是0x20读不到身份证。
	SetReg(JREG_CONTROL,0x10);
	SetReg(JREG_RFCFG,0x48);
	return;
}

经过上面的修改后，刷身份证可以成功识别到了，但是还不能读UID。因为身份证不是标准的B类卡，需要使用下面的流程读取UID：


1. REQB
发: 05 00 00
收: 50 00 00 00 00 d1 03 86 0c 00 80 80

2. ATTRIB
发: 1d 00 00 00 00 00 08 01 08
收: 08

3. UID
发: 00 36 00 00 08
收: xx xx xx xx xx xx xx xx 90 00
UID是前面8个字节

C语言快速画直线和画圆的代码

Thu, 15 Oct 2020 08:44:29 +0000

具体算法的原理我没有深入研究，总之用来快速画直线和画圆是目前很成熟的算法，拿来就用了^-^ 整个算法过程中只用了整数加减和移位，非常适用于运算能力有限的单片机系统。以下代码只需要把SetPixel替换为目标平台的画点函数就可以了。

//-------------------------------------------------------------------------------------------------
//画直线(x1,y1为起点坐标，x2,y2为终点坐标，绘制的直线包括起点，但不包括终点)
void DrawLine(int x1, int y1, int x2, int y2, int color)
{
	int di;
	int dx;
	int dy;
	int gx;
	int gy;
	di = 0;
	gx = (x2 > x1) ? 1 : -1;
	gy = (y2 > y1) ? 1 : -1;
	dx = (x2 - x1) * gx + 1;
	dy = (y2 - y1) * gy + 1;
	if(dx >= dy)
	{
		for(/*x2 += gx*/; x1 != x2; x1 += gx)
		{
			di += dy;
			if(di <= dx)
			{
				SetPixel(dc, x1, y1, color);
				continue;
			}
			while((di > dx) && (y1 != y2))
			{
				di -= dx;
				y1 += gy;
				SetPixel(dc, x1, y1, color);
			}
		}
	}
	else
	{
		for(/*y2 += gw*/; y1 != y2; y1 += gy)
		{
			di += dx;
			if(di <= dy)
			{
				SetPixel(dc, x1, y1, color);
				continue;
			}
			while((di > dy) && (x1 != x2))
			{
				di -= dy;
				x1 += gx;
				SetPixel(dc, x1, y1, color);
			}
		}
	}
}

//-------------------------------------------------------------------------------------------------
//画圆(x,y为圆心坐标，r为圆的半径，圆心的真实物理位置是x,y这个像素的左上角)
void DrawCircle(int x, int y, int r, int color)
{
	int  xi;
	int  yi;
	int  di;
	di = 0 - (r >> 1);
	xi = 0;
	yi = r;
	while(yi >= xi)
	{
		SetPixel(x + xi - 1, y + yi - 1, color);
		SetPixel(x + yi - 1, y + xi - 1, color);
		SetPixel(x - xi, y + yi - 1, color);
		SetPixel(x - yi, y + xi - 1, color);
		SetPixel(x - xi, y - yi, color);
		SetPixel(x - yi, y - xi, color);
		SetPixel(x + xi - 1, y - yi, color);
		SetPixel(x + yi - 1, y - xi, color);
		xi++;
		if (di < 0)
		{
			di += xi;
		}
		else
		{
			yi--;
			di += xi - yi;
		}
	}
}

已知问题：画圆时会有一些像素点被重复绘制。

经过验证的GPIO模拟I2C时序代码

Tue, 22 Sep 2020 12:04:24 +0000

使用STM32的GPIO模拟I2C总线时序，GPIO设置为开漏模式，SDA和SCK外部必须使用上拉电阻，一般是4.7K。

开漏模式的好处是，可以同时读取输入电平，而无需切换输入/输出模式。

注意事项：在开漏模式输出高电平，是释放总线，从机可以拉低；而输出低电平，则是锁住总线，从机无法拉高。

下面是代码：

/******************************************************************************
* I2C驱动(GPIO模拟)
* 蒋晓岗<kerndev@foxmail.com>
* 2020.09.22
******************************************************************************/
#include <stdint.h>
#include "delay.h"
#include "gpio.h"
#include "i2c.h"

#define	SCK_SET(ctx,x)	gpio_write((ctx)->sck_port,(ctx)->sck_pin,(x))
#define	SCK_GET(ctx)	gpio_read((ctx)->sck_port,(ctx)->sck_pin)
#define	SDA_SET(ctx,x)	gpio_write((ctx)->sda_port,(ctx)->sda_pin,(x))
#define	SDA_GET(ctx)	gpio_read((ctx)->sda_port,(ctx)->sda_pin)
#define DELAY(x)        delay_us(x)

struct i2c_contex
{
	int sck_port;
	int sck_pin;
	int sda_port;
	int sda_pin;
};

#define GET_HW_CTX(id)  (&m_i2c_ctx[id])
static struct i2c_contex m_i2c_ctx[4]=
{
	//SCK   SDA
    {PA,12, PA,11},
    {PA, 8, PC, 9},
	{PC,10, PC,12},
};

//初始化GPIO
static void i2c_gpio_init(int id)
{
	struct i2c_contex *ctx;
	ctx = GET_HW_CTX(id);
	gpio_open(ctx->sck_port, ctx->sck_pin, GPIO_MODE_OUT, GPIO_OUT_OD);
	gpio_open(ctx->sda_port, ctx->sda_pin, GPIO_MODE_OUT, GPIO_OUT_OD);
	SDA_SET(ctx, 1);
	SCK_SET(ctx, 1);
}

//产生起始条件
static void i2c_start(struct i2c_contex *ctx)
{
	SDA_SET(ctx, 1);
	SCK_SET(ctx, 1);
	DELAY(2);
	SDA_SET(ctx, 0);
	DELAY(2);
	SCK_SET(ctx, 0);
}

//产生停止条件
static void i2c_stop(struct i2c_contex *ctx)
{
	SCK_SET(ctx, 0);
	SDA_SET(ctx, 0);
	DELAY(2);
	SCK_SET(ctx, 1);
	DELAY(2);
	SDA_SET(ctx, 1);
}

//等待应答
static uint8_t i2c_wait_ack(struct i2c_contex *ctx)
{
	uint8_t ack;
	SDA_SET(ctx, 1);
	SCK_SET(ctx, 1);
	DELAY(2);
	ack = !SDA_GET(ctx);
	SCK_SET(ctx, 0);
	return ack;
}

//发送应答
static void i2c_send_ack(struct i2c_contex *ctx, uint8_t ack)
{
	SCK_SET(ctx, 0);
	SDA_SET(ctx, !ack);
	DELAY(2);
	SCK_SET(ctx, 1);
	DELAY(2);
	SCK_SET(ctx, 0);
}

//发送字节
static void i2c_send_byte(struct i2c_contex *ctx, uint8_t data)
{
	int i;
	for(i=0; i<8; i++)
	{
		SDA_SET(ctx, (data & 0x80) >> 7);
		data <<= 1;
		DELAY(2);
		SCK_SET(ctx, 1);
		DELAY(2);
		SCK_SET(ctx, 0);
	}
}

//接收字节
static uint8_t i2c_recv_byte(struct i2c_contex *ctx)
{
	int i;
	uint8_t data;
	data = 0;
	SDA_SET(ctx, 1);
	for(i=0; i<8; i++)
	{
		SCK_SET(ctx, 0);
		DELAY(2);
		SCK_SET(ctx, 1);
		data <<= 1;
        data |= SDA_GET(ctx);
		DELAY(2);
	}
	return data;
}

//写从机数据
int i2c_xfer_tx(int id, uint8_t addr, uint8_t reg, uint8_t *buf, int size)
{
    int i;
    int ret;
    struct i2c_contex *ctx;
    ctx = GET_HW_CTX(id);
	
	i2c_start(ctx);
	i2c_send_byte(ctx, addr&0xfe);
	ret = i2c_wait_ack(ctx);
	if(!ret)
	{
		i2c_stop(ctx);
		return -1;
	}
	i2c_send_byte(ctx, reg);
	ret = i2c_wait_ack(ctx);
	if(!ret)
	{
		i2c_stop(ctx);
		return -2;
	}
    for(i=0; i<size; i++)
    {
        i2c_send_byte(ctx, buf[i]);
		ret = i2c_wait_ack(ctx);
		if(!ret)
		{
			i2c_stop(ctx);
			return -3;
		}
    }
	i2c_stop(ctx);
	return 0;
}

//读从机数据
int i2c_xfer_rx(int id, uint8_t addr, uint8_t reg, uint8_t *buf, int size)
{
    int i;
    int ret;
    struct i2c_contex *ctx;
    ctx = GET_HW_CTX(id);
	i2c_start(ctx);
	i2c_send_byte(ctx, addr&0xfe);
	ret = i2c_wait_ack(ctx);
	if(!ret)
	{
		i2c_stop(ctx);
		return -1;
	}
	i2c_send_byte(ctx, reg);
	ret = i2c_wait_ack(ctx);
	if(!ret)
	{
		i2c_stop(ctx);
		return -2;
	}
	i2c_start(ctx);
	i2c_send_byte(ctx, addr|0x01);
	ret = i2c_wait_ack(ctx);
	if(!ret)
	{
		i2c_stop(ctx);
		return -3;
	}
    for(i=0; i<size; i++)
    {
        buf[i] = i2c_recv_byte(ctx);
		i2c_send_ack(ctx, i!=(size-1));
    }
	i2c_stop(ctx);
	return 0;
}

//初始化
void i2c_init(void)
{
    i2c_gpio_init(0);
    i2c_gpio_init(1);
	i2c_gpio_init(2);
}

下面是头文件：

记录QQ群管理页面无法正常打开的问题

Wed, 02 Sep 2020 17:31:35 +0000

今日发现qun.qq.com页面不能正常打开，网页上的QQ群相关功能均无法正常使用，如下图：

用浏览器调试页面发现原来是css和js资源均无法加载。

查看css和js的链接，它们都是来自同一个域名：s1.url.cn

直接在浏览器中访问此域名，也是无法打开，得到拒绝连接的回复。

联系QQ好友，发现外省的朋友可以正常访问这个页面，但本地无法访问。

于是我在电脑上ping了一下这个域名，惊人地发现？？？？？？？

WTF？？？

这是什么鬼？？？

这个域名解析竟然到了127.0.0.1？？？

通过在线DNS检测工具，可以看到这个域名有很多个IP，怀疑是本地网络运营商的DNS被污染或者攻击了，返回了错误的IP地址，修改本地DNS为114.114.114.114之后，再次测试，可以得到正确的IP地址了，网页也能正常打开了。

用PYTHON脚本拆分M3U文件

Tue, 18 Aug 2020 08:39:25 +0000

M3U文件是播放列表文件，里面记录的是一条一条的音频或视频资源地址。

最近从网上收集了一些在线电视的资源列表，这M3U文件的形式，但这个列表长度达到1000多项内容。

而且这里面包含了太多已经失效的资源地址，手机上的APP又没有单独删除某一条地址的功能，

于是只能把它拆分为一个M3U文件一个资源，方便在手机上管理和删除。

先看看这个M3U文件长什么样：

#EXTM3U
#EXTINF:-1 ,CCTV-1蓝光
http://111.13.111.242/otttv.bj.chinamobile.com/PLTV/88888888/224/3221226226/1.m3u8
#EXTINF:-1 ,CCTV-1蓝光 
http://112.50.243.8/PLTV/88888888/224/3221225922/1.m3u8
#EXTINF:-1 ,CCTV-2蓝光 
http://111.13.111.242/otttv.bj.chinamobile.com/PLTV/88888888/224/3221226230/1.m3u8
#EXTINF:-1 ,CCTV-2蓝光 
http://112.50.243.8/PLTV/88888888/224/3221225923/1.m3u8
#EXTINF:-1 ,CCTV-3蓝光 
http://117.169.124.36:6610/ysten-businessmobile/live/cctv-3/1.m3u8
#EXTINF:-1 ,CCTV-3蓝光 
http://223.110.241.130:6610/gitv/live1/G_CCTV-3-HQ/.m3u8
#EXTINF:-1 ,CCTV-4蓝光 
http://111.13.111.242/otttv.bj.chinamobile.com/PLTV/88888888/224/3221226314/1.m3u8
#EXTINF:-1 ,CCTV-4蓝光 
http://112.50.243.8/PLTV/88888888/224/3221225802/1.m3u8
#EXTINF:-1 ,CCTV-5蓝光 
http://223.110.241.130:6610/gitv/live1/G_CCTV-5-HQ/G_CCTV-5-HQ/
#EXTINF:-1 ,CCTV-5蓝光 
http://112.17.40.145/PLTV/88888888/224/3221226687/index.m3u8

第一行是#EXTM3U表明文件类型。

第二行#EXTINF后面跟的是视频长度和视频名称。

第三行http开头的是视频在线播放的地址。

可以看出来这是个比较简单的文本格式，可以写个简单的PYTHON脚本把它进行拆分。

下面是我写好的脚本：

#从A.M3U读取文本,导出A1,A2...An.M3U.
import io
import os

#生成文件
def make_m3u_file(name, link):
	obj = open(name, mode="w+", encoding="utf8")
	obj.write("#EXTM3U\n#EXTINF:-1,")
	obj.write(name+"\n")
	obj.write(link)
	obj.close
	
#获取文件名,并去除非法字符
def get_item_name(extinf):
	name = extinf.split(",", 1)[1]
	name = name.replace(" ", "")
	name = name.replace(":", ".")
	name = name.replace("/", ".")
	name = name.replace("\\", ".")
	name = name.replace("|", ".")
	name = name.replace("?", ".")
	name = name.replace("*", ".")
	name = name.replace("<", ".")
	name = name.replace(">", ".")
	return name+".m3u"
	
#处理输入的文本文件
def m3u_dump(m3u_file):
	item_name = ""
	item_link = ""
	lines = m3u_file.readlines()
	for line in lines:
		line = line.rstrip("\r\n")
		if line.startswith("#EXTINF"):
			item_name = get_item_name(line)
		if line.startswith("http"):
			item_link = line
			print(item_name, item_link);
			make_m3u_file(item_name, item_link)
###################################################
#程序入口
m3u_file_name = input("输入文件名:")
m3u_file_obj = open(m3u_file_name, "r", encoding="utf8")
m3u_dump(m3u_file_obj)
m3u_file_obj.close()
print("处理完成!")

启动这个脚本后，输入M3U文件的路径，会在当前工作目录，生成一大堆单个的M3U文件。

MQTT协议基础资料

Thu, 09 Jul 2020 16:34:42 +0000

MQTT（Message Queuing Telemetry Transport） 是ISO 标准(ISO/IEC PRF 20922)下基于发布/订阅范式的消息协议。它工作在TCP协议之上，与HTTP同属于应用层协议，默认端口号是1883，通常情况下使用TCP长连接进行通信。

MQTT是一个C/S架构的发布/订阅模式的消息传输协议。服务器端称为 broker ，broker不负责具体业务，只负责转发客户端的消息，将客户端发布的数据，转发到所有订阅了该主题的客户端。

MQTT的应用模式是多个客户端之间的通信，某个客户端订阅了主题后，它将会收到所有客户端发布到该主题下面的数据。这个“主题”和HTTP协议中的URI类似，是一串标识符。在MQTT的协议框架下，实际处理业务数据的服务器本质上也是一个MQTT客户端。业务服务器只需要实现一个MQTT客户端，而broker已经有大量成熟的软件可以直接使用，大大降低了传统服务器软件的开发难度。因此使得MQTT在物联网场景广泛应用。

MQTT客户端一般工作流程： 1.建立TCP连接（1883端口）； 2.发送连接请求（附带客户端ID、用户名、密码等信息，进行登陆和认证），等待响应； 3.订阅一个或多个主题（还可以使用通配符）； 4.发布一个或多个主题（附带有效载荷数据）； 5.空闲时发起心跳请求，保有活连接； 6.接收已订阅的主题数据； 7.发送断开请求； 8.断开TCP连接；

MQTT协议使用2进制数据模式，数据包格式为：

固定包头	可变包头	有效载荷
最小2字节，最大5字节	可选长度	可选长度

固定包头包含控制类型和包长度：

Bit	7	6
BYTE1	MQTT控制报文的类型	用于指定控制报文类型的标志位
BYTE2	剩余长度
BYTE3	剩余长度(可选，当BYTE2大于0x80时有效)
BYTE4	剩余长度(可选，当BYTE3大于0x80时有效)
BYTE5	剩余长度(可选，当BYTE4大于0x80时有效)

可变包头和有效载荷在此不详述，详见参考资料。

使用RC522(SI522)写UID卡0扇区0块

Fri, 03 Jul 2020 14:40:01 +0000

在淘宝买的UID白卡，可以使用特殊指令写0扇区0块，达到修改卡号的目的。

一开始淘宝白卡各类繁多，没搞明白，查了查以下几个关键词：

IC卡：普通的S50卡，0扇区0块不可更改。

UID： 0扇区0块可以更改（使用特殊指令）。

CUID：0扇区0块可以更改（使用标准扇区读写指令）。

FUID：0扇区0块可以更改（与UID类似，但只能写一次）。

S50资料参考: https://www.cnblogs.com/SCPlatform/p/5116180.html

手上刚好有一块SI522的板子，SI522据说完全兼容MFRC522，拿来测试。

通过查阅资料，得知写UID的流程是这样的：

#1.寻卡
send:26 
recv:04 00 
#2.防冲突
send:93 20 
recv:B0 6A BC 3B 5D 
#3.选卡
send:93 70 B0 6A BC 3B 5D D9 36 
recv:08 B6 DD 
#4.休眠
send:50 00 57 CD 
#5.写0块后门指令1(7bit模式)
send:40
recv:0A 
#6.写0块后门指令2
send:43 
recv:0A 
#7.写块数据
send:A0 00 5F B1 
recv:0A 
#8.写入16字节的块数据
send:75 C5 48 37 CF 08 04 00 62 63 64 65 66 67 68 69 5C BB 
recv:0A 

#块0数据注解
75 C5 48 37: 4字节卡号
CF         : XOR卡号校验
08         : 卡容量
04 00      : 卡类型
62 63 64 65: 其它
66 67 68 69: 其它

那么，搞清楚通信数据流程后，如何实现这个流程呢？

MFC调用winhttp实现简易的HTTP服务器程序

Wed, 01 Jul 2020 16:30:35 +0000

Windows提供的winhttp函数库用来快速实现HTTP协议的应用程序，包括客户端和服务器端。

服务器开发一般流程是这样的：

1.HttpInitialize 初始化WinHTTP函数库；

2.HttpCreateHttpHandle 创建一个HTTP队列句柄，用来接收HTTP请求；

3.HttpAddUrl 绑定要监听的URL，写为http://:80/表示所有网卡80端口的HTTP请求都处理，其中的号可以改为IP地址；

4.创建一个线程用来处理HTTP请求队列；

5.HttpReceiveHttpRequest 在线程中调用此函数，接收HTTP请求，在返回的PHTTP_REQUEST结构中有我们想要的各种数据；

6.HttpReceiveRequestEntityBody 这个函数用来接收HTTP请求的BODY部分，如果数据很长需要多次调用；

7.HttpSendHttpResponse 这个函数返回响应请求的数据，可以自行设置Header和Body；

8.要结束HTTP服务器，调用CloseHandle关闭HttpCreateHttpHandle返回的队列句柄；再调用HttpTerminate清理WinHTTP函数库；

下面的代码实现了一个最简单的HTTP服务器程序，仅供参考。

用法：

创建IHttpServiceListener的派生类，实现该虚基类的OnRecvRequest函数，该函数是用于收到客户端请求时的回调函数。在回调函数中处理请求数据，如果要读取客户端POST的数据，则调用inst->RecvRequestBody；最后调用inst->SendRequestResp返回响应数据。

2.创建CHttpService类的实例，调用Create函数，提供监听端口和回调接口。

头文件:HttpService.h

#pragma once
#include <http.h>

class CHttpService;

class IHttpServiceListener
{
public:
	virtual BOOL OnRecvRequest(CHttpService *inst, PHTTP_REQUEST request)=0;
};

class CHttpService
{
public:
	CHttpService();
	BOOL Create(INT port, IHttpServiceListener *listener);
	BOOL Delete(void);
	BOOL SendRequestResp(HTTP_REQUEST_ID req_id, INT status, LPCSTR reason, LPCSTR type, HANDLE file, LPVOID mem, DWORD mem_size);
	BOOL RecvRequestBody(HTTP_REQUEST_ID req_id, HANDLE file, char *mem, DWORD mem_size);
	BOOL DoReceiveRequests();
	BOOL GetRemoteAddr(PHTTP_REQUEST request, CString &text);
public:
	static UINT AFX_CDECL RecvRequestThread(LPVOID param);
private:
	HANDLE m_req_queue;
	LPBYTE m_req_buffer;
	UINT   m_req_buffer_size;
	CWinThread *m_thread;
	IHttpServiceListener *m_listener;
};

源文件:HttpService.cpp

二维码版本与容量

Wed, 20 May 2020 16:47:50 +0000

二维码 QR - 版本与容量
版本	矩阵大小	纠错等级	八位字节

1	21	L	17
M	14	34	20
Q	11	27	16
H	7	17	10
2	25	L	32
M	26	63	38
Q	20	48	29
H	14	34	20
3	29	L	53
M	42	101	61
Q	32	77	47
H	24	58	35
4	33	L	78
M	62	149	90
Q	46	111	67
H	34	82	50
5	37	L	106
M	84	202	122
Q	60	144	87
H	44	106	64
6	41	L	134
M	106	255	154
Q	74	178	108
H	58	139	84
7	45	L	154
M	122	293	178
Q	86	207	125
H	64	154	93
8	49	L	192
M	152	365	221
Q	108	259	157
H	84	202	122
9	53	L	230
M	180	432	262
Q	130	312	189
H	98	235	143
10	57	L	271
M	213	513	311
Q	151	364	221
H	119	288	174

C语言在Windows控制台生成二维码

Wed, 20 May 2020 10:10:37 +0000

近期为了研究C语言生成二维码，实现了一个简单的工具，在windows的控制台显示二维码，效果如下：

生成二维码的代码是从网上找的；

控制台显示二维码的主要原理是改变控制台的字符背景颜色来实现。

黑块是默认颜色，白块是修改字符背景色为白色，并输出空格来实现。

由于默认字体是8*16的，所以为了保持比例正常，一个方块要输出两个空格字符。

下面是在控制台输出色块的关键代码：

//在控制台画色块
//蒋晓岗<kerndev@foxmail.com>
#include <Windows.h>
#include "paint.h"

static HANDLE m_stdout;
static CONSOLE_SCREEN_BUFFER_INFO m_csbi;

void begin_paint(void)
{
	m_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
	GetConsoleScreenBufferInfo(m_stdout, &m_csbi);
}

void end_paint(void)
{
	SetConsoleTextAttribute(m_stdout, m_csbi.wAttributes);
}

void draw_block(int color)
{
	WORD attr;
	attr = color ? (BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_INTENSITY) : 0;
	SetConsoleTextAttribute(m_stdout, attr);
	WriteConsoleA(m_stdout, "  ", 2, NULL, NULL);
}

void new_line(void)
{
	WriteConsoleA(m_stdout, "\r\n", 2, NULL, NULL);
}

完整源码我也上传到码云了，工程是用VS2005建立的。

需要完整源码的可以扫上面的二维码，或者点击下面的链接：

源码下载： https://gitee.com/kerndev/qrencode

JHM3000体温传感器驱动

Tue, 21 Apr 2020 08:35:30 +0000

因2020疫情影响，国内突然就冒出来一堆做体温计的厂商。。。

硬件平台：nRF52832 + JHM3000

JHM3000是个单线通信的体温传感器芯片，线性度较好，校准后精度可达0.1度。

主要问题是通信是单IO输出，芯片上电后，IO就会不停地输出脉冲信号，需要MCU计算脉宽来解码数据。

每个采样周期为：2.8ms间隔 + 6ms数据传输

相邻两个高脉宽之比决定数据类型，START=3:3， BIT0=5:1， BIT1=1:5 数据样本：91,3,3,1,6,1,5,5,1,1,5,5,1,1,5,1,5,6,1,1,5,6,1,1,5,5,2,1,5,5,1,91,3,4,… 每次采样共1个START+14个BIT数据：S+BBBBBBBBBBBBB

解码数据的时候，需要先找到START数据，然后才开始解析采样数据。

下面是主要源码：

/*
* JHM3000 体温传感器驱动程序
* 每次采样2.8ms + 数据传输6ms
* 单线IO输出,相邻两个高脉宽之比决定数据,START=3:3, BIT0=5:1, BIT1=1:5
* 数据样本：61,4,3,1,5,1,6,5,1,1,6,5,1,1,5,1,5,1,5,6,1,1,5,6,1,5,1,1,6,1,5,
*           91,3,3,1,6,1,5,5,1,1,5,5,1,1,5,1,5,6,1,1,5,6,1,1,5,5,2,1,5,5,1,
*           91,3,4,...
* 每次采样共1个START+14个BIT数据：S+BBBBBBBBBBBBB
* 蒋晓岗<kerndev@foxmail.com>
* 2020.03.06
*/
#include <stdint.h>
#include <stdbool.h>
#include "log.h"
#include "bsp.h"
#include "sdk.h"

//判断数据类型，错误返回0, 成功返回1，S位bit=-1，BIT10，BIT1返回1
static int decode_one_bit(uint32_t t1, uint32_t t2, int *bit)
{
	uint32_t diff;
	if((t1 + t2) > 10)
	{
		LOG("t1=%d, t2=%d\r\n", t1, t2);
		return 0;
	}
	if(t1 > t2)
	{
		diff = t1 - t2;
		if(diff > t2)
		{
			*bit = 0;
			return 1;
		}
	}
	if(t2 > t1)
	{
		diff = t2 - t1;
		if(diff > t1)
		{
			*bit = 1;
			return 1;
		}
	}
	*bit = -1;
	return 1;
}

//等待管脚电平跳变
static int wait_pin_state(int state, uint32_t timeout)
{
	uint32_t diff;
	uint32_t tick;
	diff = 0;
	tick = app_timer_cnt_get();
	timeout = timeout << 5; //1毫秒约等于32个时钟
	while(diff < timeout)
	{
		if(nrf_gpio_pin_read(HM3000_PIN_DATA) == state)
		{
			return 1;
		}
		else
		{
			app_timer_cnt_diff_compute(app_timer_cnt_get(), tick, &diff);
		}
	}
	return 0;
}

//计算高电平时长
static int calc_pulse_width(uint32_t *pw)
{
	int ret;
	uint32_t diff;
	uint32_t tick;
	ret = wait_pin_state(1, 5);
	if(!ret)
	{
		return 0;
	}
	tick = app_timer_cnt_get();
	ret = wait_pin_state(0, 5);
	if(!ret)
	{
		return 0;
	}
	app_timer_cnt_diff_compute(app_timer_cnt_get(), tick, &diff);
	*pw = diff;
	return 1;
}

//等待高电平结束
static int wait_for_idle(void)
{
	return wait_pin_state(0, 5);
}

//等待ADC采样开始
//ADC采样有2.5ms高电平
static int wait_for_adc(void)
{
	int i;
	int ret;
	uint32_t pw;
	for(i=0; i<32; i++)
	{
		ret = calc_pulse_width(&pw);
		if(!ret)
		{
			return 0;
		}
		if(pw > 30)
		{
			return 1;
		}
	}
	return 0;
}

//接收一位数据
static int recv_one_bit(int *bit)
{
	int ret;
	uint32_t t1;
	uint32_t t2;
	ret = calc_pulse_width(&t1);
	if(!ret)
	{
		return 0;
	}
	ret = calc_pulse_width(&t2);
	if(!ret)
	{
		return 0;
	}
	return decode_one_bit(t1, t2, bit);
}

//接收采样起始信号
static int recv_start_bit(void)
{
	int ret;
	int bit;
	ret = recv_one_bit(&bit);
	if(!ret)
	{
		return 0;
	}
	return bit == -1;
}

//接收采样数据
//数据=1位符号+13位数据
static int recv_adc_data(int *data)
{
	int i;
	int bit;
	int ret;
	int16_t tmp;
	tmp = 0;
	for(i=0; i<14; i++)
	{
		ret = recv_one_bit(&bit);
		if(!ret)
		{
			LOG("drv_hm3000: recv bit%d failed!\r\n", i);
			return 0;
		}
		if(bit < 0)
		{
			LOG("drv_hm3000: recv bit%d invalid!\r\n", i);
			return 0;
		}
		if(bit)
		{
			tmp |= 1 << (15 - i);
		}
	}
	//LOG("drv_hm3000: raw=%d\r\n", tmp);
	*data = tmp >> 2;
	return 1;
}

//采样数据
static int sample_data(int *data)
{
	int ret;
	ret = wait_for_idle();
	if(!ret)
	{
		LOG("drv_hm3000: wait idle timeout!\r\n");
		return 0;
	}
	ret = wait_for_adc();
	if(!ret)
	{
		LOG("drv_hm3000: wait adc timeout!\r\n");
		return 0;
	}
	ret = recv_start_bit();
	if(!ret)
	{
		LOG("drv_hm3000: recv start failed!\r\n");
		return 0;
	}
	ret = recv_adc_data(data);
	if(!ret)
	{
		LOG("drv_hm3000: recv data failed!\r\n");
		return 0;
	}
	return ret;
}

#if 0
//调试数据
static void dump_data(void)
{
	int i;
	static uint32_t time[100];
	for(i=0; i<64; i++)
	{
		calc_pulse_width(&time[i]);
	}
	for(i=0; i<64; i++)
	{
		LOG("%d,", time[i]);
	}
	LOG("\r\n");
}
#endif

//读取采样数据
int drv_hm3000_read(int *data)
{
	//dump_data();
	//return 0;
	
	int ret;
	//uint8_t sr;
	//sd_nvic_critical_region_enter(&sr);
	ret = sample_data(data);
	//sd_nvic_critical_region_exit(sr);
	return ret;
}

//打开芯片电源
void drv_hm3000_enable(void)
{
	nrf_gpio_pin_write(HM3000_PIN_PWR, 1);
}

//关闭芯片电源
void drv_hm3000_disable(void)
{
	nrf_gpio_pin_write(HM3000_PIN_PWR, 0);
}

//初始化驱动
void drv_hm3000_init(void)
{
	nrf_gpio_cfg_output(HM3000_PIN_PWR);
    nrf_gpio_cfg_input(HM3000_PIN_DATA, NRF_GPIO_PIN_NOPULL);
	nrf_gpio_pin_write(HM3000_PIN_PWR, 0);
}

C语言简易均值滤波器

Thu, 16 Apr 2020 16:03:00 +0000

均值滤波器就是取多个连续的数据，进行算术平均运算，得出输出数据；

为了简化运算，本文演示代码使用2的整数次幂进行算术平均运算，因为这种情况可以通过移位的方式来代替除法。

以下是滤波器定义的头文件：

#ifndef __FILTER_H
#define __FILTER_H

struct filter
{
    int buff[32]; //最大支持32级均值，可根据需要改为更大的值。
    int order;
    int shift;
    int sum;
    int index;
};

typedef struct filter filter_t;

//初始化滤波器，order指定滤波常数，必须是2的N次方(1,2,4,8,16...)
void filter_init(filter_t *flt, int order);

//滤波函数，value输入待滤波的数据，返回滤波后的数据
int  filter_input(filter_t *flt, int value);

//复位滤波器
void filter_reset(filter_t *flt);

#endif

以下是源文件：

/*
* 均值滤波器
* 蒋晓岗<kerndev@foxmail.com>
*/
#include <string.h>
#include "filter.h"

//均值滤波器
int filter_input(filter_t *flt, int value)
{
    flt->sum += value;
    flt->sum -= flt->buff[flt->index];
    flt->buff[flt->index] = value;
    flt->index = (flt->index + 1) & (flt->order - 1);
    return (flt->sum >> flt->shift);
}

//均值滤波器
void filter_init(filter_t *flt, int order)
{
    flt->index = 0;
    flt->sum   = 0;
    flt->order = order;
    flt->shift = 0;
    while(order > 1)
    {
        flt->shift++;
        order >>= 1;
    }
}

//复位
void filter_reset(filter_t *flt)
{
    flt->index = 0;
    flt->sum   = 0;
    memset(flt->buff, 0, sizeof(flt->buff));
}

使用nw.js制作桌面版draw.io

Mon, 30 Mar 2020 16:16:19 +0000

draw.io是一个开源的在线流程图制作软件，源码地址： https://github.com/jgraph/drawio

这个软件的特殊之处在于，它完全使用web技术开发，可以很方便地搭建在线编辑软件。

对于Windows个人用户而言，还是使用桌面程序比较好一些。

官方也提供桌面版本程序: https://github.com/jgraph/drawio-desktop

官方桌面程序是使用electron打包而成的，并且目前只提供64位版本，对于使用32位系统的我来说是个硬伤。

因此只有考虑使用它的源码自己构建Windows桌面程序了。

鉴于之前研究过阿里钉钉PC端客户端，是使用nw.js制作的，于是研究能不能用nw.js来启动draw.io？

1.首先下载官方源码，得到drawio-master.zip。

2.解压后找到drawio-master\src\main\webapp目录，复制到nw.js的根目录。

3.修改package.json

{
	"name": "draw.io",
	"main": "app://./webapp/index.html",
	"window":
	{
		"icon": "webapp/images/logo.png",
		"title":"draw.io",
		"resizable":true,
		"toolbar":false,
		"frame":true
	}
}

4.启动nw.exe

哇哦，它真的运行成功了！

体验还不错！nice！nw.js真是个好东西！

嘿嘿，我的32位系统终于用上draw.io桌面版了！

备注下：我当前使用的nw.js版本是V0.12.3，没有package.json时启动是下面这个样子的。

本来打算把我的nw.js也传上来的，发现CSDN上面已经有这个资源了，不能重复上传。

Windows平台快速切换hosts文件的小工具

Mon, 30 Mar 2020 09:14:40 +0000

上周孩子她妈跑过来说电脑上有个软件打不开了，让我给看看是怎么回事。

做为一个程序员，外行人眼中修电脑什么的肯定都是必备技能啊！

我走过去看了看，这个软件就是SwitchHosts!，具体问题当时没有保存截图，总之就是报错！

最后解决的办法就是把C:\Users\Administrator.SwitchHosts这个文件夹删除就好了。

虽然问题已经解决，但是我分析了下这个软件，核心功能嘛就是切换预设的hosts文件嘛，功能并不复杂。

但是它：

1、高达100MB的程序体积（大概是为了跨平台，使用electron打包的程序）。

2、默认配置文件保存在用户主目录（这不符合我对绿色软件的定义）。

因此我突发奇想，决定使用Windows原生API重写一个真正的绿色程序，

按照我理解的绿色程序应该具有以下特点：

1、免安装，解压即用；

2、不写注册表，程序数据和配置文件保存在程序目录下面；

3、打包整个程序目录放到U盘，可以在任意电脑上打开，并得到相同的配置参数；

好的，说干就干。

于是我打开VS2005，新建一个MFC工程，然后此处省略1万字……………………

终于一个界面丑陋，功能简单的hosts切换工具就产生了。

界面布局参考了SwitchHosts!，左边是配置文件的列表，右边可以查看和编辑配置文件的内容。

左侧的配置文件列表点鼠标右键可以进行添加、删除、改名操作。

勾选对应的配置，可以同时勾选多个，则加载到系统hosts文件并执行清除DNS缓存的操作。

清除DNS缓存使用的是命令：ipconfig /flushdns

右侧的编辑框查看和修改配置文件，并实时保存配置文件的改动。

实时保存这个功能，目前采用的是当EDIT控件丢失焦点时，如果文本内容有改变，则保存一次文件。

第一次启动程序的时候会自动备份当前系统的hosts文件，命名为“默认配置”；

所有配置文件均保存在程序主目录的etc目录下面，并以.hosts为后缀；

编译出来的程序也才200多KB，比起SwitchHosts!小巧了不是一点半点。

这个工具使用纯MFC开发，源码也非常的简单，感兴趣的朋友可以到我的码云查看源码。

下载地址： https://download.csdn.net/download/qq446252221/12282814

源码地址： https://gitee.com/kerndev/HostsMan

后记：

发给孩子她妈试用，竟然打开是一坨英文+乱码！

原来hosts文件被SwitchHosts!修改过后变成了UTF8编码的UNIX文档（换行符变成了\n而不是\r\n）。

由于文本编辑使用的是EDIT控件，只能识别\r\n的换行符，

于是又修改了一下代码，把加载的文件换行符强转为\r\n，才能正常换行。

但是UTF8编码这个就有点麻烦了，暂时还不支持，只能用Notepad++先转为GBK编码吧。

补充：

用python写了个脚本把SwitchHosts!的配置导入HostsMan

#!python
#从SwitchHosts!导入配置文件
#蒋晓岗<446252221@qq.com>
import io
import os
import json

#创建子目录etc
def safe_mkdir(name):
	try:
		os.mkdir(name)
	except:
		return None

#保存配置
def save_hosts(dir, name, data):
	print("正在导入:", name)
	hosts = open(dir + "\\" + name + ".hosts", "w")
	hosts.write(data)
	hosts.close()

#入口
home = os.environ["USERPROFILE"]
file_name = home + "\\.SwitchHosts\\data.json"
file_obj = open(file_name, "r", encoding="utf8")
json_str = file_obj.read()
file_obj.close()
list_obj = json.loads(json_str)
for data in list_obj["list"]:
	title = data["title"]
	content = data["content"]
	safe_mkdir("etc")
	save_hosts("etc", title, content)

Windows更新信任证书颁发机构列表

Sat, 28 Mar 2020 12:56:58 +0000

Windows系统内置的信任根证书是需要随时更新的，

任意打开一个HTTPS网站，如果发现其证书不是由受信任的根证书颁发机构提供的，那么有两种可能：

一、本地储存的根证书太旧了，需要更新，这时就会触发系统自动请求证书；

二、这个证书确实不是有效的，那么给出无效证书的警告；

有时候安装某些带有数字证书的软件的时候，也会检查证书，如果自动更新没有成功，那么就会提示：

无法建立到信任根颁发机构的证书链！

这时就需要手动更新：

检查电脑网络是否通畅；
检查“任务计划程序库” > “Microsoft” > “Windows” > “CertificateServicesClient” 下面有没有3个项目。

打开浏览器访问一些HTTPS的站点试试；

4.重启电脑再次安装软件；

5.实在不行就等等吧，有时候系统它过几天自己就好了。

6.尝试安装补丁KB2813430(windows 7)

嵌入式软件编程规范（C语言）

Mon, 09 Mar 2020 10:23:16 +0000

〇、前言

代码编程我认为也是一门艺术，优美的代码使人赏心悦目。然而编程规范并没有唯一的行业标准，就像windows和linux的代码各具风格。本文是作者本人在多年嵌入式软件开发中所总结出的一些经验，仅作读者参考。

一、排版格式

0.在同一个项目中的所有代码应保持一致的代码风格，引用第三方库文件源码的除外。 1.代码行首缩进使用TAB键，TAB宽度设置为4个字符。 2. 一条语句占一行，不要把多条语句写到一行。 3. 每行代码不要超过100个字符，含有字符串的语句可酌情延长（如打印日志）。 4. 这些关键字须独占一行：if、else、for、do、while、switch、case、default等。 5. 所有的if、else、for、do、while语句后面都要加上花括号{}。 6. 代码块的花括号{}应独占一行，并且保持代码块和花括号缩进对齐。 7. 相对独立的代码块之间应添加一个空行分隔开。 8. 在文件末尾添加一个空行。 9. 定义指针变量时星号的位置应远离类型，向右靠近变量。 10.函数的多个参数之间使用一个空格隔开，有利于阅读。

二、注释

0.注释的原则是以人为本，注释语言尽量使用简体中文，必须准确、简洁、易懂。 1.在源文件的头部添加注释，列出该模块的关键性功能说明、作者、创建日期等。 2.对接口函数进行详细注释，列出函数的功能、输入参数、返回值。 3.对内部函数进行简要注释，列出函数的功能和必要的参数说明。 4.对代码块和函数的注释应放在其上方相邻位置，单行代码和变量注释放在右方相邻位置。 5.禁止在一行代码或表达式的中间插入注释。 6.单行注释使用//，多行注释使用/**/。

三、命名规则

0.标识符的命名要简洁明了，能够通过名称直观地了解到该标识符所表达的含义。 1.通常用一个或多个英文单词来命名，原则上禁止使用中文拼音，多个单词之间用下划线连接。 2.遇到太长的英文单词可以采用缩写的形式，缩写可以去掉元音字母或者截取单词的前面几个字母，尽量采用大家都能理解的缩写单词。 3.对于理解有困难的缩写应该加以注释。 4.变量、函数、结构体、类型定义标识符使用小写字母。 6.宏、常量、枚举成员使用大写字母。 6. 循环变量等具有特殊含义的变量可以使用单个字符作为变量名字（形如i、j、k）。 7. 变量命名不要在变量名前面添加冗余类型前缀。例如：unsigned int ui_size; 改为：unsigned int size; 8. 防止全局变量和静态变量与局部变量冲突，可添加特定前缀(g_、m_)表明作用域。 9. 使用typedef定义的类型标识符使用“_t”做为后缀。 10. 作用域为全局范围的函数、宏、枚举成员，应使用模块化的命名规则。即：以模块/对象名作为前缀。

四、声明与定义

0.尽量使用编程语言提供的标准数据类型，如char、int、float等。 1.不要自行定义固定字长的数据类型，因为标准库<stdint.h>已经提供了此类型(如uint8_t、int32_t等)。 2.谨慎使用条件编译功能，因为条件编译会降低代码可读性。 3.项目中广泛引用的数据类型或定义，应考虑把它们集中到一个头文件中，如<define.h>。 4.频繁使用的代码块应考虑定义成为函数。 5.避免随机乱序定义变量，将具有关联性的变量定义放到一起。 6.文件内部引用的全局变量和函数必须加上static声明。 7.被引用的枚举类型应使用typedef定义为自定义类型。 8.结构体的使用者如果不会访问其成员变量，则应使用typedef定义为自定义类型。 9.每个.c文件最多只能有一个与之对应的.h头文件声明其对外输出的接口函数。 10.明确头文件的使用者，不要在头文件中定义使用者不关心的数据定义或函数。

五、模块化编程

0.模块化编程即是把整个项目代码分解为一个个功能独立的模块，良好的模块化设计可以极大地提高代码的维护性和复用性。 1.一个模块通常由一个或多个.c源文件和一个声明接口的.h头文件组成。 2.模块化设计的关键在于分解功能，一个模块只实现较为独立的单一功能。 3.根据模块所实现的功能大致分为应用层、功能层、驱动层，可以细分更多层次。 4.应用层属于最顶层，是整个项目业务需求最直观的体现，依赖于下层的模块。应用层的模块通常提供的接口函数很少，且都是初始化、启动、停止等操作。 5.功能层属于中间层，一般用于连接应用层和驱动层的桥梁，是实现业务需求的支柱。功能层的模块通常处理驱动层的数据传递给应用层，比如协议解析，数据处理等。 6.驱动层属于最低层，负责和底层硬件打交道，只处理硬件数据，不关心具体应用。因此驱动层的代码应该具有很强的可复用性，在不同的项目中应该可以直接重复使用。 7.函数调用层次需遵循上层模块调用同层或下层模块的接口，切勿在底层模块中直接调用上层模块的函数。 8.模块之间通信使用轮寻或回调函数的方式，降低各模块之间的耦合性。

由DLL文件生成LIB文件

Fri, 28 Feb 2020 18:40:35 +0000

网上广泛使用的方法，经过测试没有成功！因为DLL导出名和编译链接时使用的名称不一样，导致编译通不过。一种是xxx@nn格式，还有一种是__imp_xxx@XYZ格式。如果手动修改DEF文件里面的函数名为链接所需的名字，编译能通过，但运行时提示找不到XXX函数的入口点。

经过一番百度，终于找到一位高人所写的文章和工具解决了我的问题！文章地址： https://bbs.csdn.net/topics/390707917

生成DEF文件后，手工修改函数为以下格式：

LIBRARY demo.dll

EXPORTS
Initialize@12=Initialize
CalcCRC@8=CalcCRC

Initialize@12=Initialize前面的@12表示这个函数有3个参数，等号后面的Initialize是DLL导出函数的原始名字。生成lib文件后，再用ImpLibEditor工具的Change To [Undecorate]功能修改函数名，最后另存为新的lib文件即可。

相关工具已经上传到网盘。下载地址： https://share.weiyun.com/5zM4Wfq

I2C接口读取MPU9250磁力数值

Mon, 13 Jan 2020 16:27:25 +0000

一开始拿到芯片手册云里雾里，根本没有找到关于磁力数据的寄存器，结果上网一查才知道，这芯片竟然是个胶水芯片。。。

MPU9250内部是MPU6050和AK8963两个芯片合并在一起的，感觉傻傻的。

内部的AK8963是负责三轴磁力传感器采样的芯片，它通过I2C总线与MPU9250连接在一起。

如上图所示，MPU9250还集成了一个I2C主机控制器。默认情况下MPU9250用它的I2C主机控制器与AK8963通信，把磁力值读到出放到指定的寄存器中，这需要设置一堆寄存器，真是麻烦得一逼！！！

幸好MPU9250还预留了I2C直通模式，这个模式相当于MPU9250和AK8963共同使用一条I2C总线，因为它们的通信地址不一样，

MPU9250的地址：0xD0/0xD1

AK8963的地址：0x18/0x19

在写驱动程序的时候，可以把它们当作硬件上分离的两个芯片挂在同一条I2C总线上。

直通模式需要设置MPU9250的第55号寄存器的Bit1写1即可开启。

有了直通模式我们就可以直接与AK8963通信了，AK8963的寄存器不多。

下面讲讲几个关键寄存器操作：

0x00:这个寄存器是芯片ID=0x48，能读出这个ID证明通信OK了。

0x0A:设置工作模式，建议上电后先写入0x0F，读取出芯片校准系数；然后再写0x01，进行单次采样。

0x02:状态寄存器，BIT0为1表示采样完成，可以读取采样数据了。网上有人说读不到数据，加上10毫秒延时就能读出数据，就是因为没有检查状态值。经过实验测试单次采样大概需要6-8毫秒。

0x03-0x08:数据寄存器，三个轴，每个轴的数据都分为高8位和低8位，组成16位的有符号整数。

0x10-0x12:校准寄存器，出厂设置的校准参数，当0x0A寄存器写入0x0F后才可以读出来。

手册上写了数据校准参数的用法：

Hadj是校准后的数据；

H是读出来的原始采样数据；

ASA是校准寄存器读出来的参数；

得到正确的三轴磁力数值后，就可以用来实现一个简单的电子指南针了。

在水平面的方向＝180 + arctan(Y, X) * 180 / PI;

由于环境干扰，还需要加入一个平面校准算法：将芯片在水平面原地转360度，记录三个轴的采样值的最大值和最小值，求得(最大值+最小值)除以2得到偏移值。将原始采样值减去偏移值之后，再送入上面的公式计算角度会更准确。

EC20模块内置协议栈的开发笔记

Tue, 29 Oct 2019 16:25:09 +0000

本文主要记录如何通过UART接口发送AT指令进行网络连接。

前言

EC20是4G全网通模块。从手册上看类似的模块应该还有EG9x和EM05

硬件

硬件上使用一路UART接口与模块通信，UART接口默认使用115200波特率。模块上电就会启动，可以通过拉低RESET管脚对模块进行复位操作。

软件

AT命令的格式：发送方是以AT开头0x0D结尾的字符串，格式比较统一。模块响应是以0x0D,0x0A结尾，但开头字符是没有统一的格式，有的指令响应是以+开头，有的又没有。

AT指令软件初始化流程仅供参考：

第1步：等待模块就绪由于模块上电就会启动，启动时间大约10秒。所以主机最好延时10秒再循环发送AT，等待模块响应OK，表示模块通信就绪了。如果发送了多次都没有响应，则可以给模块来一个复位信号。再重复上面的操作。

第2步：基本参数设置 2.1 发送ATE0，关闭指令回显。如果不关闭回显，主机发什么，模块就会原样回复，适合于在终端软件里人工发送命令，可以看到输入指令。但是我们做产品是用程序去发指令，指令回显不利于写代码解析响应数据，所以关掉为好。 2.2 发送AT+CREG=0，取消注册状态主动上报注册状态通过AT+CREG?查询就行了，可以不用主动上报。 2.3 发送AT+CMEE=2，设置错误反馈方式设置为0所有的错误都会返回ERROR. 设置为2某些指令错误会返回+CME ERROR:给出详细的错误信息 2.4 发送AT+QCFG=“nwscanmode”,0设置模块搜网模式通过这个指令可以锁定4G或2G网络。具体的取值定义可以看手册：

第3步：模块识别主机发送ATI或者AT+GMM，可以得到模块型号。发送ATI，还可以获取模块固件版本号信息。

第4步：检测SIM卡主机发送AT+CPIN?，可以得到SIM卡状态。这条指令很好解析，响应是格式是+CPIN: 检测到接收的内容是+CPIN开头，就可以确定这是指令应答，而不是模块主动上报的干扰数据。当为READY时表示SIM卡也就绪了，可以进行下一步操作了。当为其它状态时，看手册吧，反正是不正常的状态。发送AT+CIMI可以得到IMSI信息，从号码的前5位可以判断这张卡是哪家运营商，比如46000是中国移动，46001是中国联通。


第5步：等待注册网络
主机发送AT+CREG?
模块响应+CREG:,
当stat的值为1或者5时，表示注册成功。
可以发送AT+COPS?查询当前注册的是哪家运营商
可以发送AT+CSQ查询信号强度1-31，31表示信号最强
第6步：激活GPRS数据连接
主机发送AT+QICSGP=1,1,,,设置APN接入点。
模块响应：OK
主机发送AT+QIACT=1激活GPRS数据连接。
模块响应：OK
第7步：其它信息
发送AT+QIACT?查询当前IP地址。
发送AT+QNWINFO查询当前网络参数。
至此模块的网络初始化完成了。
可以进行网络通信了。
第8步：连接远程服务器
发送AT+QIOPEN=1,,“TCP”,,,0,1
是通道号码，模块支持1-4通道，可以理解为socket句柄。
可以是域名也可以是IP地址。
是服务器端口。
最后的参数1表示使用Direct Push Mode。此模式模块会将接收数据主动上报过来。
模块响应：OK
模块响应：+QIOPEN: ,
响应的是连接状态，0表示连接成功，非0表示连接失败，手册有详细错误代码。
这里要注意：
模块是先返回应答OK，然后再返回连接状态。
如果网络不好模块会很过长时间才返回连接状态。
在模块返回连接状态之前，主机可以发送AT+QICLOSE=提前结束连接，
此时模块会先返回OK，再返回+QIOPEN: ,567



BM817模块内置协议栈的开发笔记
Mon, 28 Oct 2019 16:54:17 +0000
BM817和U8300C是非常相似的4G全网通模块；
AT指令初始化流程也几乎相同，可以参照U8300C的使用方法。
重点说一下不同之处：
1.设置模块搜网模式指令是：AT+BMMODODR=11
此处的值定义见手册：

2.此模块注册到电信HDR网络时使用的指令集会不同。
通过模块上报的^MODE: 2状态来决定通用指令集，
当状态值为2，4，8时模块使用3GPP2指令模式。
此模式：
AT+QCPIN?代替AT+CPIN?
AT+QCIMI代替AT+CIMI
AT+CCSQ代替AT+CSQ
3.连接服务器指令AT+MIPOPEN多一个连接超时的参数。
AT+MIPOPEN=,0,,,0,
是连接超时时间，单位是秒。


U8300W模块内置协议栈的开发笔记
Thu, 24 Oct 2019 09:28:13 +0000
本文主要记录如何通过UART接口发送AT指令进行GPRS网络连接。
前言
U8300W是LTE制式的4G网络模块，支持移动和联通4G网络。
类似的模块的还有U8300C、U7500、C5300。
U8300C是支持电信4G的全网通模块。
U7500是只支持联通3G模块。
C5300是只支持电信3G模块。
这几个模块的开发方式是一样的，支持的AT命令也都差不多。
硬件
硬件上使用一路UART接口与模块通信，UART接口默认使用115200波特率。
模块上电就会启动，可以通过拉低RESET管脚对模块进行复位操作。
软件
AT命令的格式：
发送方是以AT开头0x0D结尾的字符串，格式比较统一。
模块响应是以0x0D,0x0A结尾，但开头字符是没有统一的格式，有的指令响应是以+开头，有的又没有。
AT指令软件初始化流程仅供参考：
第1步：等待模块就绪
由于模块上电就会启动，但启动时模块的UART接口会打印模块的启动日志，大约持续30秒。
所以主机最好延时30秒再循环发送AT，等待模块响应OK，表示模块通信就绪了。
如果发送了多次都没有响应，则可以给模块来一个复位信号。
再重复上面的操作。
第2步：基本参数设置
2.1 发送ATE0，关闭指令回显。
如果不关闭回显，主机发什么，模块就会原样回复，适合于在终端软件里人工发送命令，可以看到输入指令。
但是我们做产品是用程序去发指令，指令回显不利于写代码解析响应数据，所以关掉为好。
2.2 发送AT+CREG=0，取消注册状态主动上报
注册状态通过AT+CREG?查询就行了，可以不用主动上报。
2.3 发送AT+CMEE=2，设置错误反馈方式
设置为0所有的错误都会返回ERROR.
设置为2某些指令错误会返回+CME ERROR:给出详细的错误信息
2.4 发送AT+MODODR=2，设置模块搜网模式
U8300可以通过这个指令设置锁定4G或2G网络。
第3步：模块识别
主机发送AT+GMM，可以得到模块型号。
但是这条指令的响应内容就是模块型号字符串，没有固定的头和尾，解析比较困难，
如果发这条指令之后，模块突然主动上报一些其它内容，不要把干扰数据当成模块型号了！
发送ATI也可以得到模块型号，还可以获取模块固件版本号信息。
第4步：检测SIM卡
主机发送AT+CPIN?，可以得到SIM卡状态。
这条指令很好解析，响应是格式是+CPIN: 
检测到接收的内容是+CPIN开头，就可以确定这是指令应答，而不是模块主动上报的干扰数据。
当为READY时表示SIM卡也就绪了，可以进行下一步操作了。
当为其它状态时，看手册吧，反正是不正常的状态。
发送AT+CIMI可以得到IMSI信息，从号码的前5位可以判断这张卡是哪家运营商，
比如46000是中国移动，46001是中国联通。

第5步：等待注册网络
主机发送AT+CREG?
模块响应+CREG:,
当stat的值为1或者5时，表示注册成功。
可以发送AT+COPS?查询当前注册的是哪家运营商
可以发送AT+CSQ查询信号强度1-31，31表示信号最强
第6步：激活GPRS数据连接
主机发送AT+MIPPROFILE=1,,,设置APN接入点。
模块响应：OK
主机发送AT+MIPCALL=1激活GPRS数据连接。
模块响应：+MIPCALL:
模块响应：OK
第7步：数据连接相关的参数设置
发送AT+MIPHEX=1，设置数据格式
内嵌TCP/IP协议栈发送数据时采用16进制字符串的格式，而不使用原始二进制数据。
至此模块的网络初始化完成了。
可以进行网络通信了。
第8步：连接远程服务器
发送AT+MIPOPEN=,0,,,0
是通道号码，模块支持1-4通道，可以理解为socket句柄。
可以是域名也可以是IP地址。
是服务器端口。
模块响应：+MIPOPEN:,
模块响应：OK
响应的是连接状态，1表示连接成功，0表示连接失败。


SIM800模块内置协议栈的开发笔记
Thu, 17 Oct 2019 12:52:04 +0000
本文主要记录如何通过UART接口发送AT指令进行GPRS网络连接。
前言
SIM800是GSM制式的2G网络模块，支持移动和联通2G网络。
类似的模块的还有SIM900和SIM2000，
SIM2000是CDMA制式的模块，仅支持电信2G网络。
这三个模块的开发方式是一样的，支持的AT命令也都差不多。
但是2019年了，2G模块基本也属于淘汰级别的产品了。
硬件
硬件上使用一路UART接口与模块通信，UART接口默认使用115200波特率。
这个模块比较奇葩！
还需要一个GPIO控制模块的电源开关PWRKEY。
开机需要将模块的PWRKEY引脚拉低1.2秒才能开机。
开机后再给个1.2秒的低脉冲，模块还会关机。
软件
AT命令的格式：
发送方是以AT开头0x0D结尾的字符串，格式比较统一。
模块响应是以0x0D,0x0A结尾，但开头字符是没有统一的格式，有的指令响应是以+开头，有的又没有。
软件开发的难点：
由于模块会主动上报一些数据，比如来电会上报RING。
并不是主机发一条AT命令，模块才会响应一条数据。
如果在主机发送一条命令的时候，模块突然主动上报了一些信息，
更让人头疼的是响应的数据还没有统一的格式，
这就给软件解析响应数据带来了麻烦，难以判断接收到的数据是什么东西？
解决办法 只能先判断接收到的数据是不是主动上报的内容，如果不是再根据上一次发送的指令类型来解析响应数据。
但我目前还不能确定模块主动上报的内容和命令响应的内容有没有重叠的，如果有重叠的，那就GG了。
AT指令软件初始化流程，仅供参考：
第1步：等待模块就绪
由于这个模块奇葩的上电流程，软件没办法确认模块现在是不是上电了？
所以这一步主机先循环发送AT，等待模块响应OK，表示模块通信就绪了。
如果发送了多次都没有响应，则给模块来一个上电流程：PWRKEY低脉冲1.2秒。
再重复上面的操作。
第2步：基本参数设置
2.1 发送ATE0，关闭指令回显。
如果不关闭回显，主机发什么，模块就会原样回复，适合于在终端软件里人工发送命令，可以看到输入指令。
但是我们做产品是用程序去发指令，指令回显不利于写代码解析响应数据，所以关掉为好。
2.2 发送AT+CREG=0，取消注册状态主动上报
注册状态通过AT+CREG?查询就行了，可以不用主动上报。
2.3 发送AT+CMEE=2，设置错误反馈方式
设置为0所有的错误都会返回ERROR.
设置为2某些指令错误会返回+CME ERROR:给出详细的错误信息
第3步：模块识别
主机发送AT+GMM，可以得到模块型号。
但是这条指令的响应内容就是模块型号字符串，没有固定的头和尾，解析比较困难，
如果发这条指令之后，模块突然主动上报一些其它内容，不要把干扰数据当成模块型号了！
第4步：检测SIM卡
主机发送AT+CPIN?，可以得到SIM卡状态。
这条指令很好解析，响应是格式是+CPIN: 
检测到接收的内容是+CPIN开头，就可以确定这是指令应答，而不是模块主动上报的干扰数据。
当为READY时表示SIM卡也就绪了，可以进行下一步操作了。
当为其它状态时，看手册吧，反正是不正常的状态。
可以发送AT+CIMI得到IMSI信息，从号码的前5位可以判断这张卡是哪家运营商，
比如46000是中国移动，46001是中国联通。

第5步：等待注册网络
主机发送AT+CREG?
模块响应+CREG:,
当stat的值为1或者5时，表示注册成功。
可以发送AT+COPS?查询当前注册的是哪家运营商
可以发送AT+CSQ查询信号强度1-31，31表示信号最强
第6步：激活GPRS数据连接
主机发送AT+CSTT=,,设置APN接入点。
模块响应OK
主机发送AT+CIICR，激活GPRS数据连接。
模块响应OK
主机发送AT+CIFSR，查询模块的IP地址。
模块响应IP地址，注意这又是一个没有前缀的响应，就是纯IP字符串。


Keil MDK-ARM历史版本下载地址
Wed, 18 Sep 2019 13:38:58 +0000
官方提供历史版本下载: http://www.keil.com/update/rvmdk.asp
目前可以看到从2.50a到5.28a的所有版本.
查看更新日志: http://www.keil.com/update/whatsnew.asp?p=MDK&v=5.28a
把最后的5.28a换为其它版本号即可查看其它版本的更新日志.



快速查询Windows内核结构体定义
Mon, 16 Sep 2019 14:26:50 +0000
搜索资料时找到一个网站
可以比较方便地查询Windows内核结构体的定义.
http://www.nirsoft.net/kernel_struct/vista/index.html
里面包含了很多公开和非公开的结构体的定义.
查询也很方便.
收藏一下.


Foxmail发送邮件乱码的临时解决办法
Thu, 12 Sep 2019 10:52:27 +0000
目前使用的版本是Foxmail 7.0.1.92, 因为这是最后一个使用经典界面的版本.

一直用了差不多5年了没有遇到什么问题.
直到昨天突然发现发出去的邮件正文是乱码,邮件标题正常,而且接收邮件是正常显示.
经过一番研究,发现这个Foxmail的一个BUG,这个BUG在7.2.6版本以后才被修复.
临时解决办法:
一. 重新设置系统语言.
设置系统语言为英文,重启电脑,发送邮件正文正常了,但是标题又乱码.
然后再改为中文.重启电脑,邮件正文还是乱码.标题正常…….
故障依旧,这个办法没有解决我的问题
二.手动选择邮件编码.
在发送邮件的时候,在菜单"格式" -> “编码” 默认选择的是西欧.
手动选择编码为GB2312或者UTF8发送邮件.每次发送的时候都要选择一次编码.

三.使用发送纯文本邮件
还有一种方案,就是发送邮件的时候,选择纯文本邮件,而不是HTML邮件,也不会出现乱码.



基于阿里钉钉网页版制作绿色版客户端
Tue, 10 Sep 2019 16:28:18 +0000
由于工作需要必须使用阿里钉钉这个聊天软件.
但随着版本更新,疯狂添加新功能,体积越来越大,无法忍受.
因此寻求体积小巧,绿色便携的PC客户端.
在下载了无数个钉钉旧版本之后,可以发现一些钉钉软件的发展历程……
最初钉钉把主要功能都在网页版上面实现.
早期的客户端都是基于网页版制作的.客户端使用nw.js把网页封装成为客户端.
后来V2.X版本核心还是nw.js但是把网页版变成了离线版(把网页版的js和css保存在本地).
后来V3.X版本开始,开发了一套rvwindow实现了本地化的GUI窗口,但核心逻辑还是js和css.
再到V4.X又重新开发了一套新的GUI,重构了整个程序框架,已经看不到网页版的影子了.
由于目前钉钉网页版还能正常使用.虽然可以用chrome直接打开,但是经常要浏览网页,一不小心就把它关闭了.
所以利用早期版本的node-webkit来包装一个网页客户端.
nw.js也就是node-webkit,它的核心是一个浏览器.可以通过package.json进行一行配置.
package.json里面有自定义user-agent,定义了nw版本,WEB端用来识别这是客户端还是浏览器.
因此可以提取出nw.js的核心文件,删除无用的文件.
再修改package.json
把user-agent修改为标准浏览器.
把启动页面修改到钉钉网页版.
再添加一行参数–user-data-dir=Data把浏览器缓存数据设置到本地路径.
这样启动DingTalk.exe就可以看到钉钉登陆界面了!.
只要网页版还能正常使用,这个"假"客户端就能继续使用.
{
  "name": "DingTalk",
  "version": "4.0.0",
  "main": "https://im.dingtalk.com",
  "chromium-args":"--disable-gpu --disable-directwrite-for-ui --user-data-dir=Data",
  "user-agent": "Mozilla/5.0 (%osinfo) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%webkit_ver Safari/537.36",
  "window": {
	"icon": "logo.ico",
	"frame" :true,
    "min_width": 1000,
    "min_height": 600,
    "width": 1000,
    "height": 600,
    "resizable": false,
	"toolbar":true,
    "transparent" : false
  },
  "webkit": {
    "plugin": false,
    "page-cache" : false
  },
  "dependencies":{
  }
}



Portable.NET一个绿色版.NET运行环境,支持.NET4.0版本
Tue, 10 Sep 2019 09:30:07 +0000
经过对飞信VMdotNET的研究,利用其核心文件进行二次开发.
得到一个绿色版的.NET运行环境.
并且添加了对.NET4.0版本的支持.
经过测试,可以在WinXP运行12306分流抢票软件.
下载地址:
https://gitee.com/kerndev/Portable.NET
由于体积限制,GIT仓库只包含少量DLL组件,运行更多EXE程序,需要完整的.NET组件.
完整.NET组件:
链接: https://pan.baidu.com/s/1XfGTpKQ9xW8JhamzYgmxWQ 提取码: afpj


让基于.NET的程序变成绿色版独立运行
Thu, 05 Sep 2019 13:13:52 +0000
临近国庆了,要抢火车票了,但是发现"12306分流"抢票软件是基于.NET4.0开发的,要求安装.NET4.0.
Windows XP集成了.NET2.0版本
Windows 7集成了.NET3.5版本
Windows 8集成了.NET4.0版本
由于目前使用的是Windows 7,没有.NET4.0环境.当然安装是没问题的.
但是作为一个系统技术爱好者,总是想研究一下与众不同的方案??? 有没有可能免安装.NET4.0环境?
百度找到一些陈旧的资料, 说明跟我有一样需求的人还是存在的.
方案一:使用MONO
MONO是为了让.NET程序跨平台的产物,支持Windows系统
软件下载地址: https://www.mono-project.com/download/stable
经过一番研究,并没有成功运行我的程序.
估计是需要用它的SDK重新编译程序,才能跨平台运行吧.
方案二:使用飞信.NET虚拟机
老版本的飞信软件,基于.NET开发,使用了定制版RemoteSoft DotNET Linker工具.
下载后发现它可以运行大部分.NET2.0版本的程序.
运行方法是FetionVM.exe your.exe
但是不能运行.NET4.0的程序.
由于它的核心方案是利用RemoteSoft DotNET Linker,所以我去找原版工具研究下.
方案三:RemoteSoft DotNET Linker
目前早已经停止更新了,官网也下线了,网上能找到的最新版本是2.1.0.
这个工具包目的就是把你的.NET程序打包为绿色版,它会自动收集所需的文件,并生成一个文件夹.
所以今天的重点就是研究RemoteSoft DotNET Linker能不能实现运行基于.NET4.0的程序.
文件夹结构如下图:

经过研究,飞信里面的FetionVM.exe其实就是mini.exe.
飞信里面的rsdeploy.dll版本号是1.0.6
这里下载的rsdeploy.dll版本号是2.1.0,这个版本可能要新一些?
尝试打包一个小工具后,发现要打包的目标程序会被命名为mini.rsm文件.由mini.exe进行启动.
还会生成一个文件夹结构,与飞信非常类似.
飞信的FetionVM.exe也是加载FetionVM.rsm,这个FetionVM.rsm就是一个空的.NET引导程序.
它会运行命令行参数指定的程序.经过实验验证这种方案兼容性要差一些.
兼容性最好的办法是直接把要运行的程序改为为mini.rsm,由mini.exe直接运行.成功率高很多.
由于它们提供的.NET版本都是2.0.50727,为了研究它能不能支持.NET4.0的程序.
对工具包的文件结构进行了分析,经过分析这套工具的原理大概是类似于IO重定向,
运行.NET程序时需要访问的注册表和文件都重定向到本地目录.
mdeploy.registry这个文件就是重定向的虚拟注册表.
另外还有一个叫c的文件夹,里面装的是windows\assemly.这就是重定向的虚拟系统盘路径.
基于这个原理,我猜测理论上应该是可以支持任意版本的.NET程序的!
毕竟Windows系统的核心内容不就是注册表和文件组成的吗?…………………………
为了证明这个猜测,我从装好.NET4.0的虚拟机里面提取出.NET4.0相关的所有文件,以及注册表.
把注册表中HKLM\SOFTWARE的内容导出到mdeploy.registry
把虚拟机C:\Windows\Microsoft.NET\Framework下面的v4.0.30319全部复制到本地文件夹.
把虚拟机C:\Windows\assemly下面的文件全部复制到本地文件夹.
把bypass.exe改名为mini.rsm运行mini.exe测试一下.
报错!…….
报错!…….
报错!…….
这个时候轮到procmon上场了,跟踪一下是缺少哪个文件?
唔,发现一个问题,它要加载c\windows\assembly\GAC_MSIL\System\4.0.0.0__b77a5c561934e089
而实际上在安装好.NET4的Windows7系统中并没有这个文件.
搜索了一下,发现微软真是奇葩,竟然把.NET4的GAC文件移到了C:\Windows\Microsoft.NET\assembly文件夹.
而C:\Windows\assembly下面只有.NET2.0的GAC文件!!!
把这些缺失的文件拷贝到本地目录,再次测试…..
还是报错!…….
还是报错!…….
还是报错!…….


如何从MSU系统补丁里提取出所需要的文件?
Fri, 30 Aug 2019 17:59:57 +0000
Windows补丁文件是*.msu格式, 这是一种压缩文件格式.
正常情况下,只需要双击这个文件就可以安装补丁.
但是我不想安装更新,只想从里面提取出某个dll文件 ,怎么办?
首先用7-zip打开这个msu文件,可以正常打开,发现里面有如下文件结构:

我们所需要的目标文件,就在那个.cab文件包里面.
继续用7-zip打开这个.cab包,发现如下文件结构:

看上去好像正常打开了.cab文件,但是却没有找到真正的目标文件.
真正的目标文件应该是这个0,1这两个文件,但是它们无法再继续解压了.
经过一番研究,没有办法继续了.
只得寻求百度的帮助,找到了一个方法.
用系统提供的命令行工具expand.exe可以正确地解压这个.cab文件.
方法如下:
expand -F:* windows6.1-kb3042553-x86.cab X:\PATH
X:\PATH是我们要解压的目标路径,可以使用相对路径,但需要保证目录必须存在.
解压后得到如下文件结构:

这里面终于找到了我们需要的目标文件http.sys.
大功造成!


MFC默认的多国语言实现方法
Wed, 28 Aug 2019 15:40:22 +0000
关于MFC多国语言的实现方法,网上给出的主流方案是:
一. 自己实现
从ini或者xml文件读取字符串,根据需要动态填充到控件或者菜单中.
这种方法通用性好,甚至可以实现动态切换界面语言,但实现起来比较复杂,需要自己写很多代码.
二.加载纯资源文件
生成一个纯资源的DLL文件,每种语言一个DLL文件.
在程序启动的时候,一般是XXX::InitInstance()函数中添加以下代码:
HINSTANCE hDll;
hDll = ::LoadLibrary(L"xxx.dll");
AfxSetResourceHandle(hDll); 
加载不同的xxx.dll就会显示不同的语言.
今天我在这里主要记录一下第三种方案:
这种方案和第二方案非常相似,也是生成纯资源DLL文件,每种语言一个DLL.
但不同的是不需要我们手动加载资源,MFC其实会自动加载多语言DLL.
这个技术叫做Satellite DLLs.MFC从7.0版本开始就已经支持这种技术.
但此方法网上讨论者非常少,相关的介绍资料也很少.
官方资料只找到这一篇: https://docs.microsoft.com/en-us/cpp/build/localized-resources-in-mfc-applications-satellite-dlls
这种方案运行原理是,MFC应用程序在运行时会自动加载合适的多语言资源文件 .
比如我的应用程序文件名叫app.exe,那么在运行时会自动在当前目录下加载appxxx.dll.
xxx表示不同的语言,这3个字母有哪些组合没有找到资料,但已知的组合有:

  
      
          CHS
          简体中文
      
  
  
      
          CHT
          繁体中文
      
      
          DEU
          德语
      
      
          ENU
          英语
      
      
          ESN
          西班牙语
      
      
          FRA
          法语
      
      
          ITA
          意大利语
      
      
          JPN
          日语
      
      
          KOR
          朝鲜语
      
      
          RUS
          俄语
      
      
          LOC
          默认语言
      
  

LOC是个特殊的组合,它表示默认语言,当以上指定语言文件都找不到时,最后会使用LOC.dll.
如果连LOC.dll都没有呢,那就相当于没有多国语言了,使用应用程序自带的资源做为界面显示.


Windows系统自带端口转发功能
Tue, 27 Aug 2019 11:20:43 +0000
一、使用如下命令把127.0.0.1:80转发到192.168.1.1:80：
netsh interface portproxy add v4tov4 listenaddress=127.0.0.1 listenport=80 connectaddress=192.168.1.1 connectport=80
二、使用如下命令取消端口转发：
netsh interface portproxy delete v4tov4 listenaddress=127.0.0.1 listenport=80
三、使用如下命令查看转发状态：
netsh interface portproxy show v4tov4



Jlink烧写SPI Flash存储芯片(W25QXX)
Wed, 21 Aug 2019 10:46:00 +0000
JLink支持SPI协议，可以使用JFlashSPI.exe来烧录SPI FLASH芯片。
JLink的20PIN管脚定义如下：

而SPI接口所使用的接口与JTAG是复用的。

  
      
          管脚序号
          JTAG定义
          SPI定义
      
  
  
      
          5
          TDI
          MOSI
      
      
          7
          TMS
          NSS
      
      
          9
          TCK
          SCK
      
      
          13
          TDO
          MISO
      
  

需要注意的是，除了SPI接口外，还要连接VCC和GND，否则也识别不到芯片的。
硬件连接完成后，就可以打开JFlashSPI.exe测试烧录了。
点击connect会得到以下错误提示：

因为JLink无法自动检测这个SPI Flash芯片。
但是从日志可以看到SPI Flash ID已经成功读出来了：0xC8 40 15
所以需要进入设置，手动为FLASH设置读写参数。
根据芯片编程手册，填写对应的参数，如下：

这样设置后，就可以正常读写W25QXX系列的SPI FLASH芯片了。


收集一些Windows系统非常严重的安全漏洞
Thu, 15 Aug 2019 10:52:01 +0000
今年Windows爆出了太多远程漏洞，这些漏洞主要存在于SMB和RDP服务。
感觉有必要收集一下这些严重漏洞。
首先在微软官方提供的安全更新指南查询： https://portal.msrc.microsoft.com/zh-cn/security-guidance
获取补丁编号后到这个链接下载更新补丁： https://www.catalog.update.microsoft.com/search.aspx?q=kb编号
这里列出几个影响重大的漏洞：

  
      
          漏洞编号
          备注
          补丁编号(Win7)
      
  
  
      
          CVE-2017-0143
          SMB
          KB4012212
      
      
          CVE-2017-0144
          SMB
          KB4012212
      
      
          CVE-2017-0145
          SMB
          KB4012212
      
      
          CVE-2017-0146
          SMB
          KB4012212
      
      
          CVE-2017-0147
          SMB
          KB4012212
      
      
          CVE-2017-0148
          SMB
          KB4012212
      
      
          CVE-2017-11780
          SMB
          KB4041678
      
      
          CVE-2019-0708
          RDP
          KB4499175
      
      
          CVE-2019-1181
          RDP
          KB4512486
      
      
          CVE-2019-1182
          RDP
          KB4512486
      
  



制作Win7PE精简版的经验总结笔记二
Wed, 14 Aug 2019 15:23:04 +0000
这篇文章是接上一篇，主要写关于注册表的内容。
WinPE的注册表本质是几个文件，但这些文件不能直接编辑，需要用regedit或者Registry Workshop。
它们存放在\Windows\System32\config目录。
这个目录下面有这些子目录和文件：
 Journal/
 RegBack/ 
 SystemProfile/
 TxR/
 BCD-Template
 COMPONENTS
 DEFAULT
 SAM
 SECURITY
 SOFTWARE
 SYSTEM
其中PE系统只使用以下文件，其余文件可删除。
 DEFAULT
 SAM
 SECURITY
 SOFTWARE
 SYSTEM
DEFAULT是用户默认设置的注册表项，开机后会加载到HKEY_USERS.DEFAULT
SAM是空的，不用管它，保留就行了。
SECURITY是空的，不用管它，保留就行了。
SOFTWARE是计算机软件设置，开机后会加载到HKEY_LOCAL_MACHINE\SOFTWARE
SYSTEM是计算机系统设置，开机后加载到HKEY_LOCAL_MACHINE\SYSTEM
下面就分别总结各个注册表项

HKEY_LOCAL_MACHINE\SYSTEM
PE系统能不能正常启动，开机会不会蓝屏？最重要的就是这里的内容。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Class
描述了设备类型的GUID，每个GUID表示一种设备类型。
在进入设备管理器手动安装设备驱动时，
如果选择“从计算机的设备驱动程序列表中选择”就会看到当前系统支持的所有设备类型，
这个列表的内容就来自这个注册表项。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\ComputerName\ActiveComputerName
ComputerName="WinPE"
这里可以设置计算机名称
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase
这是一条很关键是注册表，里面记录了系统启动时需要安装驱动的关键设备列表。
这个作用和WXPE的TXTSETUP.SIF差不多，每一项设备ID下面都记录了设备类型和驱动路径。
比如：
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\PCI#VEN_8086&DEV_2412&CC_0C0300]
"ClassGUID"="{36FC9E60-C465-11CF-8056-444553540000}"
"Service"="usbuhci"
"DriverPackageId"="usbport.inf_x86_neutral_f9abf85fd00186bd"
ClassGUID就是上面所说的设备类型
Service表示驱动程序服务名称，这个在HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\servicess
DriverPackageId大概就是驱动路径，在\Windows\System32\driverstor下面有对应的文件。

关键设备列表非常大，可以删除一些。
我试过全部删除，PE系统启动速度会非常快！但是进系统后无法操作，因为没有加载鼠标键盘驱动。
所以需要酌情删除。
这里有一个比较好的优化方案，把可以使用兼容ID匹配的设备精简为一条内容。
比如：
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\PCI#CC_0C0300
这表示PCI设备且设备类型为0C0300的设备，这个类型表示uhci(USB1.1)控制器，加载usbuhci驱动。
它可以通配所有的uhci控制器设备，不管是intel的还是amd的芯片组。
所以我们可以删除类似于
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\PCI#VEN_8086&DEV_2412&CC_0C0300]
这一类的VEN&DEV的精确匹配。
因为可以用兼容ID通配所有的uhci控制器，就没有必要再为不同的厂商都写一堆设备了。
类似的兼容ID还有很多，比如：
IDE控制器：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\PCI#CC_0101
AHCI控制器：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CriticalDeviceDatabase\PCI#CC_010601
这样一来就可以删除大量重复的注册表内容。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layouts
这一条是键盘布局，也就是不同语言的输入法列表，一般PE系统只保留00000409(英文)就行了
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SafeBoot
人如其名，它就是记录了安全模式启动，要开启哪些驱动和服务。
我们PE系统都是正常启动，不会用F8进入安全模式，所以可以把它全部删除。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\ScsiPort\SpecialTargetList
特殊SCSI设备列表，看了一下，没见过这些设备，所以都删除了吧。
虽然不知道它们为什么会出现在这里。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment
系统级的环境变量，没什么好删除的，但需要知道它在这里。
HKEY_LOCAL_MACHINE\WPE_SYSTEM\ControlSet001\Control\ProductOptions
有没有觉得ProductPolicy的内容太长了，有几十KB。
它记录了当前系统的策略，决定了系统是否包含某些功能，如win7基础版，专业版，旗舰版。
HKEY_LOCAL_MACHINE\WPE_SYSTEM\ControlSet001\services
这一项很重要，记录了系统的驱动和服务。
如果开机蓝屏，报某个.sys找不到，可以来这里删除对应的驱动，成功进入系统。
或者开机蓝屏，报某个.sys出现异常，可以来这里删除对应的驱动，成功进入系统。
服务就是计算机管理里面的那个服务。
有很多是PE系统用不到的，比如.NETFramework,AudioEndpointBuilder,bthserv等等，实再太多了。
删掉这些，服务管理列表看着就清爽了。就不会有那么多无法加载的服务项。
关于SYSTEM注册表的内容就总结到这些，还有更多的内容，也没精力去分析了。


制作Win7PE精简版的经验总结笔记
Wed, 14 Aug 2019 12:59:30 +0000
写这篇文章的主要目的是做笔记和总结一些经验。
首先是WinPE的文件目录：

Program Files
这个目录是程序目录，里面的文件可以全部删除，只保留一个文件就行了：
/Program Files/Internet Explorer/ieproxy.dll
没有这个文件会导致总是在新窗口打开文件夹！

ProgramData
这个目录是程序数据目录，里面与PE有关的就是有几个默认的开始菜单项目。
如果没有什么要求， 是可以全部删除的，我这里保留了一个文件：
ProgramData\Microsoft\Network\Connections\Pbk\rasphone.pbk
因为添加网络功能时，顺便把PPPOE宽带连接功能也保留了，需要用到这个文件。

Users
这个目录是用户配置目录，在PE系统只有一个Default用户。
里面有一些桌面图标，开始菜单，发送到桌面快捷方式，用户图标等。
我不需要这些，所以全部删除。

sources
这个目录是原版安装程序包含的资源，PE系统不需要，直接删除。

Windows
这个目录是核心系统目录了，子目录太多，不能全部介绍了。
我保留了以下目录，这差不多是PE系统最精简的目录结构了：
 Branding
 Fonts
 Globalization
 inf
 resources
 system32
 winsxs
 zh-CN
 explorer.exe
 regedit.exe
 WindowsShell.Manifest

关于字体
Fonts目录是字体目录，原版有好几百M的字库，PE里用不到那么多字体，只需要保留少量几个就行了：
marlett.ttf
simsun.ttc
tahoma.ttf
vga936.fon
vgafix.fon
vgaoem.fon
vgasys.fon
简体中文系统最主要的字体是宋体(simsun.ttc)。
simsun.ttc原版有15MB，可以使用精简版，只需要2.5MB

关于主题
resources目录包含主题文件，保留了经典主题文件classic.theme，否则界面风格有点怪异，
还要保留themeui.dll才能正常使用经典主题，在这个问题上卡了很久时间。
没有这个DLL鼠标指针会变成默认风格很模糊。
我想要的是Windows经典主题，并关闭所有显示动画效果，还需要配合注册表修改才能实现。

关于winsxs：
win7的winsxs非常大，它几乎保留了完整的系统文件，主要是用于系统更新，PE系统并不需要更新系统。
里面99%的文件都可以删除，但以下文件是必须的：
winsxs/
├─manifests
│      x86_microsoft.windows.c..-controls.resources_6595b64144ccf1df_5.82.7600.16385_zh-cn_6189e316803d96d4.manifest
│      x86_microsoft.windows.c..-controls.resources_6595b64144ccf1df_6.0.7600.16385_zh-cn_b7a33d2d3f47b7fb.manifest
│      x86_microsoft.windows.common-controls_6595b64144ccf1df_5.82.7600.16385_none_ebf82fc36c758ad5.manifest
│      x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc.manifest
│      x86_microsoft.windows.gdiplus_6595b64144ccf1df_1.1.7600.16385_none_72fc7cbf861225ca.manifest
│      x86_microsoft.windows.i..utomation.proxystub_6595b64144ccf1df_1.0.7600.16385_none_9d148a8db8d32238.manifest
│      x86_microsoft.windows.isolationautomation_6595b64144ccf1df_1.0.0.0_none_35d357a66c38ade4.manifest
│      x86_microsoft.windows.systemcompatible_6595b64144ccf1df_6.0.7600.16385_none_49adccbde8169a03.manifest
├─x86_microsoft.windows.c..-controls.resources_6595b64144ccf1df_5.82.7600.16385_zh-cn_6189e316803d96d4
├─x86_microsoft.windows.c..-controls.resources_6595b64144ccf1df_6.0.7600.16385_zh-cn_b7a33d2d3f47b7fb
├─x86_microsoft.windows.common-controls_6595b64144ccf1df_5.82.7600.16385_none_ebf82fc36c758ad5
├─x86_microsoft.windows.common-controls_6595b64144ccf1df_6.0.7600.16385_none_421189da2b7fabfc
└─x86_microsoft.windows.gdiplus_6595b64144ccf1df_1.1.7600.16385_none_72fc7cbf861225ca
其中manifest下面的以下3个文件比较神秘，没有它们开机会蓝屏：


打造适用于KVM云服务器的极简Win7PE（仅80MB）
Wed, 14 Aug 2019 11:26:53 +0000
鉴于之前折腾WXPE的失败经验，在折腾Win7PE之前，先不考虑体积和功能，找一个通用的Win7PE做个实验。
发现Win7PE比WXPE要稳定得多，没有鼠标丢失问题，安装驱动也很顺利！
于是开始玩命折腾，先定一个小目标：
一、Win7PE只需要BOOT.WIM文件就可以了，用系统自带的Bootmgr就可以引导；
二、体积一定要小于100M，最好小于85M，才能塞进100M的隐藏分区；
三、要求能正常安装virtio驱动；
四、支持网络功能，可以运行FTP软件上传和下载文件；
五、集成最基本的系统维护工具；
最终选择Windows7 32位企业版为基础制作这个PE。
第一.32位比64位体积更小巧，对内存要求也更小；
第二.企业版比旗舰版的安装文件要更小；
第三.不带SP1的版本比带SP1的体积更小，对于PE系统来说有没有SP1补丁并不影响使用；
首先是解压ISO，提取BOOT.WIM和INSTALL.WIM，
然后合并文件，导入注册表，修改注册表。。。
这些基本操作就略过了。。。
最重要的精简系统文件和添加网络功能。
参考了这个文章： http://blog.sina.com.cn/s/blog_18cbdaad80102y18t.html
非常感谢这位博主的分享，节省了不少时间进行初步的精简工作。
在基本功能满足要求的情况下，进一步精简无用文件和注册表项。
使用虚拟机反复测试，使最终WIM文件的体积在85M以内。
整个过程费时又费脑
此处省略1万字。。。。。。。。。。
此处省略1万字。。。。。。。。。。
最终获得了一个比较满意的极简PE。
此PE不含维护工具只有80M，加上维护工具85M。
为了优化体积，对注册表进行了大量精简，去掉了一些右键菜单。
为了优化体积，删除了大量系统自带的但是不常用的驱动。
保留了PPPOE和RNDIS驱动，可以做为本地电脑维护时上网使用。
集成Virtio驱动使用PECMD来加载，保证注册表纯净无污染。
内置工具都放在Program Files目录，保证Windows目录纯净无污染。
内置工具集成了常用维护工具，FTP服务器，磁盘分区工具，这些都没有添加到桌面图标；
注意事项：
1.此PE保留了系统自带的磁盘碎片整理工具，如果无法启动？
需要手动到“计算机管理->服务”手动打开“Task Scheduler”服务。
2.此PE保留了宽带连接(PPPOE)功能，如果提示启动失败？
需要手动到“计算机管理->服务”手动打开“Windows Event Log”服务。
系统截图：

在服务器和本地电脑上测试了一下，感觉很不错。
送上链接分享给有需要的朋友：
https://download.csdn.net/download/qq446252221/11545155
仅含BOOT.WIM文件
如果使用Bootmgr引导wim文件，还需要一个BOOT.SDI文件，可以从安装光盘提取出来。
本地硬盘启动时，自己通过BootICE添加一个WIM启动项即可。
U盘启动时，格式为FAT/FAT32，使用BootICE修改引导程序为Bootmgr，再添加一个WIM的启动项即可。


在KVM虚拟化云主机上使用WXPE的研究
Thu, 08 Aug 2019 13:15:41 +0000
云服务器系统运行Windows Server 2008 R2，有100M的隐藏启动分区。
为了对服务器的重装系统等日常维护工作，需要运行一个PE系统，最好能装进这个100M的启动分区。
要求体积要小巧，首先想到的就是WXPE了，WXPE虽然古老，但体积非常小巧，核心文件压缩后只有20M左右。
于是在硬盘里找出我珍藏多年的WXPE.ISO。
上传到服务器，将100M隐藏分区分配到A盘，并上传GRLDR，用GRLDR来引导WXPE。
重启系统后，成功看到WXPE的界面，但是不能识别云硬盘，而且鼠标会失去反应，只能纯键盘操作。
KVM虚拟机，需要安装virtio驱动，才能识别硬盘。
所以到官网下载virtio-win驱动: https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/
需要将viostor.sys驱动集成到WXPE中。
下面就要简单分析一下WXPE.ISO的文件结构：
├── WINNT.XPE
├── WXPE
│   ├── NTDETECT.COM
│   └── SETUPLDR.BIN
└── WXPE.IS_
引导扇区会加载SETUPLDR.BIN，然后读取WINNT.XPE中的引导参数
WINNT.XPE指定了要加载到内存的镜像文件，文件内容如下
[SetupData]
BootDevice="ramdisk(0)"
BootPath="\WXPE\SYSTEM32\"
OsLoadOptions="/minint /fastdetect /rdexportascd /rdpath=WXPE.IS_"
其中/rdpath参数指定了内存镜像的文件路径，就是根目录下的WXPE.IS_
在WXPE中会经常看到*.IS_，.DL_，.SY_，*.EX_这样的后缀名，其实是一个压缩文件.
解压后会把后缀名还原为*.ISO,.DLL,.SYS,*.EXE
我们把WXPE.IS_解压得到WXPE.ISO，再把它解压得到WXPE的系统目录。
在\WXPE目录下有一个TXTSETUP.SIF，这个文件是WXPE启动后非常重要的文件 。
[SourceDisksFiles] 这个章节是可以删除的。
[HardwareIdsDatabase] 这个章节描述了系统启动中要检测和安装的设备列表。
比如GenDisk=“Disk”,{4D36E967-E325-11CE-BFC1-08002BE10318}
表示设备ID为GenDisk的设备，驱动程序为"Disk"，设备类型为{4D36E967-E325-11CE-BFC1-08002BE10318}
再往下能找到disk=disk.sys，表示Disk驱动对应的文件是disk.sys。
这个设备列表很长，其中有80%的内容都是可以删除的，减少这些内容，可以明显加快系统启动速度。
在设备列表里删除一些内容，就可以安全地删除对应的\WXPE\system32\drivers下面的sys文件。
比如下面的这些设备，我用了10多年的电脑也从来没见过。
si3132r5="Silicon Image 3132 SoftRaid 5 Controller"
si3132="Silicon Image 3132 SATALink Controller"
si3124r5="Silicon Image 3124 SoftRaid 5 Controller"
si3124r="Silicon Image 3124 SATARaid Controller"
si3124="Silicon Image 3124 SATALink Controller"
si3114r5="Silicon Image 3114 SoftRaid 5 Controller"
si3114r="Silicon Image 3114 SATARaid Controller"
si3114="Silicon Image 3114 SATALink Controller"
si3112r="Silicon Image 3112 SATARaid Controller"
si3112="Silicon Image 3112 SATALink Controller"
于是我决定干掉这些内容，可以加快系统启动速度，何乐不为？


IIS7安装URLReWrite的妙用
Fri, 19 Jul 2019 18:05:50 +0000
IIS7默认是没有URLRewrite这个模块的,需要自行下载安装。
官方下载地址: https://www.iis.net/downloads/microsoft/url-rewrite
安装了这个模块后,就可以实现重写URL请求了。
应用场景一：隐藏后缀名
比如浏览器请求的是http://127.0.0.1/api/demo
我们可以利用URLRewrite把请求地址在末尾自动添加上.php,这样就可以实现无后缀访问了。
配置方式：
使用通配符匹配：api/*
重写URL：api/{R:1}.php

说明：
对api/*的任意访问，都会自动添加.php后缀。
{R:1}表示被*匹配到的内容
如果通配表达式有两个*，可以用{R:2}引用第二个*
应用场景二：重定向
比如浏览器请求的是http://127.0.0.1/download/file.zip
我们把它重定向到http://127.0.0.1/api/download.php?path=/file.zip
这样就可以控制文件下载的权限。
配置方式：
使用通配符匹配：/download/*
重写URL：/api/download.php?path={R:1}

说明：
对download/*的任意访问，都会重定向到/api/download.php
并且加上查询参数?path=*



nginx-rtmp-win32的权限管理(事件回调)
Fri, 12 Jul 2019 19:26:23 +0000
上一次研究了如何搭建nginx-rtmp服务器，以及推流和观看直播。
但是问题是只要知道直播地址，任何人都可以往rtmp://127.0.0.1/live推送视频流。
如何管理权限以及实现多个房间(多个频道)直播？
一、多个房间(多个频道)
这个比较简单，一个RTMP服务器本来就支持多个直播流，只需要改变推流地址就可以。
比如改为:rtmp://127.0.0.1/live/123456，那么就得到一条名为123456的直播流。
这个123456就可以理解为房间号，或者频道号。
当然在OSB里地址不是这样写的，应该这样写：

二、权限管理
nginx-rtmp提供了一个webapi回调接口，需要在配置文件添加以下配置：
publish_notify on;
notify_method get;
on_publish http://127.0.0.1/api/live/auth;
on_publish_done http://127.0.0.1/api/live/auth;
on_play http://127.0.0.1/api/live/auth;
on_play_done http://127.0.0.1/api/live/auth;
当收到推流或者播放事件时，会自动调用这些API，并且传递一些必要的参数过去。
如果API返回200表示认证成功，返回404表示认证失败。
要实现权限管理，重点就是分析传递过来的这些参数。
默认情况下是以POST方式传递参数，但是可以使用notify_method修改为GET方式。
我觉得GET方式可能比POST方便一些。
参数格式是：application/x-www-form-urlencoded
参数长什么样？
我这里测试的结果是这样的：
开始推流时我收到这样的请求：
http://127.0.0.1/api/live/auth?

app=live&flashver=FMLE/3.0%20(compatible%3B%20FMSc/1.0)&swfurl=rtmp://127.0.0.1/live&tcurl=rtmp://127.0.0.1/live&pageurl=&addr=127.0.0.1&clientid=7&call=publish&name=123456&type=live
当我关闭OBS时收到这样的请求：
http://127.0.0.1/api/live/auth?app=live&flashver=FMLE/3.0%20(compatible%3B%20FMSc/1.0)&swfurl=rtmp://127.0.0.1/live&tcurl=rtmp://127.0.0.1/live&pageurl=&addr=127.0.0.1&clientid=7&call=publish_done&name=123456
从这两个测试结果可以看出来，包含以下参数：
app=live
flashver=FMLE/3.0%20(compatible%3B%20FMSc/1.0)
swfurl=rtmp://148.70.143.48/live
tcurl=rtmp://148.70.143.48/live
pageurl=
addr=113.87.163.76
clientid=7
call=publish
name=123456
type=live
两种情况只有call参数和name不一样，
call参数表示事件类型：一个是publish，另一个是publish_done。
name参数表示我们设定的房间号。
其它参数我们可以不去关心。
要实验身份认证，那么我们可以从这个name参数入手，在name里面添加一些认证信息。
比如把房间号设定为123456?user=admin&pass=admin
假设定义user=用户名，pass=密码，然后通过解析这些值，最终实现用户权限管理。
最后：
房间号如果不写？而用其它&#这些特殊符号，可能会被编码为%xx，还可能导致在本地生成临时文件夹失败。
所以应该使用123456?aaa=bbb&ccc=ddd这样的写法。
这样nginx会自动把aaa=bbb添加到查询字符串当中去。


nginx-rtmp-win32搭建RTMP流服务器的一篇笔记
Fri, 12 Jul 2019 16:31:12 +0000
RTMP是一种基于TCP协议的视频流传输协议，默认端口号是1935。
RTMP服务器监听端口，接收来自推流客户端的视频数据，并转发给拉流客户端。
支持一人推送，万人观看！像电视直播或者游戏直播都是采用该技术。
nginx-rtmp-win32就是这样的一个RTMP服务器；
nginx官方下载的windows版本是不带rtmp模块的，目前最新稳定版本是1.16；
要添加rtmp模块需要自己用源码编译，不过好在有前人做好了win32的移植。
nginx-rtmp-win32在这里下载： https://github.com/illuspas/nginx-rtmp-win32
虽然该项目已经停止更新了，但是对于个人搭建学习和测试用的RTMP服务器还是没有问题的。
有了RTMP服务器，那么还需要客户端软件：
推流可以使用OBS这类软件；
拉流可以使用PotPlayer这类播放器。
直播过程中视频数据流是从OBS传输到nginx再传输到播放器，只要网速够快，就可以获得超低延时的视频直播。
如果想在网页上观看视频直播？
由于浏览器不支持rtmp协议，所以需在网页上嵌入一个adobe flash player插件来接收并播放视频流。
目前好像也有基于js的纯H5播放器可以实现，没有去深入研究。
另外还有一种选择是苹果的HLS技术，HLS技术就是把视频流分成无数个TS视频片段。
再通过HTTP协议传输这些视频片段，实现了浏览器观看视频直播。
目前android和ios的浏览器都支持这种技术。
HLS技术一般只应用于拉流，而推流还是使用RTMP协议。
但由于服务器需要对接收的数据进行分片，直播延时比较大。
nginx-rtmp-win32非常不错，也支持HLS技术。
它可以把接收到的视频流保存为无数个TS文件，并自动生成m3u8列表，浏览器只要访问对应的m3u8就可以观看直播了。
说了这么多理论上的东西，该来实践一下了。
本次实践的内容是使用OBS推流，然后使用HLS技术，在iPhone的浏览器里面观看直播。
首先是编辑nginx的配置文件，打开nginx/conf/nginx.conf
参考下面的参数进行配置：
worker_processes 1;
error_log logs/error.log debug;
 
events
{
    worker_connections  100;
}
 
#设置RTMP服务器参数
rtmp
{
    server
    {
        listen 1935;  #设置监听端口
        application live    #设置访问路径(rtmp://127.0.0.1/live)
        {
            live on; #开启rtmp直播功能
            deny play all;#禁止RTMP播放(默认推流地址就是播放地址)
            hls on; #开启hls功能
            hls_path temp/rtmp_temp; #设置hls视频文件存放路径
            hls_fragment 5; #设置分片时长(秒)
			hls_playlist_length 10; #设置播放列表时长(秒)
            hls_continuous off; #不使用连续模式
            hls_cleanup on; #自动清理视频文件(这个默认是打开的，可以不用设置)
            hls_nested on; #嵌套模式(为每个直播流创建一个子文件夹)
            hls_fragment_naming sequential; #ts命令规则为序号递加
        }
    }
}
 
#设置HTTP服务器参数
http
{
    include       mime.types;
    default_type  application/octet-stream;
    
    server_tokens off;
    sendfile      on;
    server
    {
        listen       80;
        server_name  localhost;
 
        #下面是默认的根目录
        location /
        {
            root   html;
            index  index.html index.htm;
            autoindex on;
            autoindex_exact_size off;
            autoindex_localtime on;
        }
		location /stat
		{
            rtmp_stat all;
            rtmp_stat_stylesheet stat.xsl;
        }
        location /stat.xsl
		{
            root html;
        }
        #下面是直播观看地址
        location /live
        {
            alias  temp/rtmp_temp;
			index  index.m3u8;
			autoindex on;
            types
			{  
                application/vnd.apple.mpegurl m3u8;  
                video/mp2t ts;  
            }
        }
    }
}
配置文件修改好了，就可以双击nginx.exe启动了。


C语言调用python脚本
Sat, 29 Jun 2019 12:47:19 +0000
python提供了C语言的API，可以使用C语言调用python脚本。
参考链接： https://docs.python.org/3/c-api/
API接口函数很多，一时半会儿也看不完，先快速实现在C语言程序内执行py脚本再说吧，做个笔记。
#define Py_LIMITED_API
#include <stdio.h>
#include <Windows.h>
#include "python.h"

int py_init(void)
{
    Py_SetPythonHome(L"C:\Python");
    return 0;
}

int py_exec(wchar_t *script)
{
    wchar_t *argv[2];
    argv[0] = L"python";
    argv[1] = script;
    return Py_Main(2, argv);
}

int main(void)
{
    int ret;
    wchar_t *script = L"X:\Path\demo.py";
    ret = py_init();
    ret = py_exec(script);
    return ret;
}
解释一下：
#define Py_LIMITED_API 表示只使用python3.dll提供的API函数，兼容性较强，否则会调用python36.dll。
Py_SetPythonHome(home) 设置python的根目录，否则会报错，找不到
Py_Main(argc, argv) 调用python的主函数，没有参数的话会进入python命令行，给2个参数就可以执行指定脚本。


User Profile Service服务未能登录
Thu, 27 Jun 2019 10:46:29 +0000
在Windows Server 2008 R2上面创建一个标准用户来用运行一些低权限进程。
发现这个标准用户无法正常登陆，提示User Profile Service服务未能登录。
在管理员账号下使用Shift+鼠标右键，选择“以其它用户身份运行”也失败，提示“系统找不到指定的文件”
在命令行下面输入：runas /user:xxx calc.exe也提示是相同的提示。
但是发现可以用runas /noprofile /user:xxx calc.exe可以正常运行。
/noprofile的作用是不加载用户配置文件，看来是这个标准用户的配置文件找不到了。
上网搜了一圈，讲的都是各种修改注册表，并不能解决此问题。
经过一番研究，终于找到了原因： 因为我把系统的默认配置文件给删除了！
默认用户配置文件在这个目录：C:\Users\Default
所以解决办法就是：
新建文件件夹：C:\Users\Default
从系统安装盘拷贝C:\Users\Default\NTUSER.DAT进去就可以了。


解决FileZilla服务器端0.9.60版本无法启动的问题
Wed, 26 Jun 2019 14:42:20 +0000
在Windows 7系统下无法运行官网下载的FileZilla Server，版本号是0.9.60
双击FileZilla Server Interface.exe会报错：
Could not load TLS libraries. Aborting start of administration interface.
看到这个提示信息，很明确是加载SSL的动态库失败了，但是程序目录下面，明明有ssleay32.dll和libeay32.dll。
为什么会加载失败呢？
好在FileZilla是开源软件，下载软件包还自带源代码，所以去源代码找到了加载过程：
首先搜索报错提示，定位到了FileZilla server.cpp第103行，其中相关源码如下：

	auto sslLoader = std::make_unique<CAsyncSslSocketLayer>(0);
	if (sslLoader->InitSSL() != 0) {
		AfxMessageBox(_T("Could not load TLS libraries. Aborting start of administration interface."), MB_ICONEXCLAMATION);
		return false;
	}
继续跟踪InitSSL函数，定位到AsyncSslSocketLayer.cpp第318行，关键代码如下：
int CAsyncSslSocketLayer::InitSSL()
{
	if (m_bSslInitialized)
		return 0;

	simple_lock lock(m_mutex);

	if (!m_nSslRefCount) {
		if (!m_sslDll2.load(_T("libeay32.dll"))) {
			return SSL_FAILURE_LOADDLLS;
		}

		bool bError = false;
		proc(m_sslDll2, BIO_ctrl_pending);
		proc(m_sslDll2, BIO_read);
		proc(m_sslDll2, BIO_ctrl);
		proc(m_sslDll2, BIO_write);
        /*以下代码太多，不列出来了。*/
}
失败信息来自m_sslDll2.load函数，于是继续定位到dll.cpp第18行，代码如下：


用C语言编写CGI程序获取浏览器UserAgent
Fri, 21 Jun 2019 10:13:40 +0000
CGI是一种比较古老的动态WEB技术，现在几乎没有直接使用CGI程序的WEB服务器了，但是作为学习研究，还是可以的。
CGI的原理是WEB服务器收到浏览器的请求时，执行对应的CGI程序，其本质是一个EXE文件。
这个EXE文件可以通过环境变量获取浏览器的请求信息，然后把页面数据输出到标准输出流(stdout)；
然后WEB服务器会把这些数据返回给浏览器。
根据这些信息，我写了一个简单的CGI程序，把浏览器的UA信息返回给浏览器，并把访问记录保存在服务器。
需要注意的是，在输出页面数据的时候，需要先给HTTP响应的头部数据，比如Content-Type: text/html，再接一个空行。
这个空行是HTTP协议头部结束的标志，后面的数据作为HTTP响应的BODY数据。
我们的HTML页面数据就作为HTTP协议的BODY。
/*
CGI环境变量
CONTENT_TYPE	这个环境变量的值指示所传递来的信息的MIME类型。目前，环境变量CONTENT_TYPE一般都是：application/x-www-form-urlencoded,他表示数据来自于HTML表单。
CONTENT_LENGTH	如果服务器与CGI程序信息的传递方式是POST，这个环境变量即使从标准输入STDIN中可以读到的有效数据的字节数。这个环境变量在读取所输入的数据时必须使用。
HTTP_COOKIE	客户机内的 COOKIE 内容。
HTTP_USER_AGENT	提供包含了版本数或其他专有数据的客户浏览器信息。
PATH_INFO	这个环境变量的值表示紧接在CGI程序名之后的其他路径信息。它常常作为CGI程序的参数出现。
QUERY_STRING	如果服务器与CGI程序信息的传递方式是GET，这个环境变量的值即使所传递的信息。这个信息经跟在CGI程序名的后面，两者中间用一个问号'?'分隔。
REMOTE_ADDR	这个环境变量的值是发送请求的客户机的IP地址，例如上面的192.168.1.67。这个值总是存在的。而且它是Web客户机需要提供给Web服务器的唯一标识，可以在CGI程序中用它来区分不同的Web客户机。
REMOTE_HOST	这个环境变量的值包含发送CGI请求的客户机的主机名。如果不支持你想查询，则无需定义此环境变量。
REQUEST_METHOD	提供脚本被调用的方法。对于使用 HTTP/1.0 协议的脚本，仅 GET 和 POST 有意义。
SCRIPT_FILENAME	CGI脚本的完整路径
SCRIPT_NAME	CGI脚本的的名称
SERVER_NAME	这是你的 WEB 服务器的主机名、别名或IP地址。
SERVER_SOFTWARE	这个环境变量的值包含了调用CGI程序的HTTP服务器的名称和版本号。例如，上面的值为Apache/2.2.14(Unix)
*/
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char local_string[1024];

const char * get_env_str(const char *name)
{
	size_t sz;
	getenv_s(&sz, local_string, 1024, name);
	return local_string;
}

const char * get_tim_str(void)
{
	struct tm tm;
	time_t t;
	t = time(NULL);
	localtime_s(&tm, &t);
	sprintf_s(local_string, 1024, "%04d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
	return local_string;
}

void main(void)
{
	FILE *fp;
	fopen_s(&fp, "access.txt", "a+");
	if(fp != NULL)
	{
		fprintf(fp, "[%s]", get_tim_str());
		fprintf(fp, "[%s]", get_env_str("REMOTE_ADDR"));
		fprintf(fp, "[%s]", get_env_str("HTTP_USER_AGENT"));
		fprintf(fp, "\n");
		fclose(fp);
	}
	printf("Content-Type: text/html\n");
	printf("\n");
	printf("<html>");
	printf("<head><meta charset=\"gbk\"/>");
	printf("<title>浏览器检测</title>");
	printf("</head>");
	printf("<body>");
	printf("<table>");
	printf("<tr><td align=\"right\">浏览器UA:</td><td>%s</td></tr>", get_env_str("HTTP_USER_AGENT"));
	printf("<tr><td align=\"right\">来访者IP:</td><td>%s</td></tr>", get_env_str("REMOTE_ADDR"));
	printf("<tr><td align=\"right\">系统时间:</td><td>%s</td></tr>", get_tim_str());
	printf("</body>");
	printf("</html>");
}
编译为index.exe，然后放到WEB服务器根目录，打开浏览器访问就可以看到数据了：


自己制做绿色版VirtualBox
Mon, 10 Jun 2019 16:24:19 +0000
Windows软件的安装过程一般都是双击setup.msi或者setup.exe来完成。
在安装的过程中主要就是：解压或复制文件到安装目录，注册程序组件，添加注册表项，安装系统驱动等。
理论上只有解压就能运行的程序，才叫绿色软件，需要写注册表，注册组件的都不算。
今天以VirtualBox V4.2.36版本为研究目标。
第一步还是正常安装程序，然后备份所有程序文件，再卸载程序。
第二步把备用文件放到工作目录，进行研究，先双击virtualBox.exe会提示严重错误：提示创建COM对象失败。

看到这个提示猜测是某些dll文件需要注册了，所以用regsvr32命令把所有的dll文件全部注册遍，
最后发现只有VBoxC.dll可以注册，其它文件都失败。
再运行主程序，还是一样的提示，看来还有遗漏的文件？可能是EXE文件，无法直接用regsvr32来注册。
只好通过解包安装程序了，查看一下安装包的安装过程来了解如果手动注册。
把VirtualBox.exe用7zip解开可以看到里面有3个文件，2个msi文件和1个cab文件。
解包后：这两个msi一个是32位，另一个是64位系统的安装程序，cab文件在安装时需要重命名为common.cab。
对于msi文件，可以用Orca来反编译，查找它的Registry表项的内容，就是我们绿化软件时需要用到的注册表。
而这些注册表项，并不是全部都需要，一些文件关联的内容，我们并不需要。
只提取最重要的部分，那就是CLSID下面的内容。

如图所示，还好VirtualBox的注册表内容并不多，只有几十行。
而我们需要的只有CLSID相关的内容，这里面主要描述了两个组件，一个是VBoxC.dll和VBoxSVC.exe
VBoxC.dll的内容，其实通过regsvr32 Vboxc.dll就完成注册了，需要手动添加的就是VBoxSVC.exe而已。
手动添加了{B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F}下面的内容后，再次运行主程序，发现已经可以打开了。
启动虚拟机报错：
NtCreateFile(\Device\VBoxDrvStub) failed: 0xc0000034 STATUS_OBJECT_NAME_NOT_FOUND (0 retries) (rc=-101)
这个问题需要安装驱动来解决：VBoxDrv.sys，这个驱动的安装嘛，就使用DPInst.exe来完成就可以了。
最后总结一下：
VirtualBox并不是真正的绿色软件，只能通过手动添加注册表的方法，来实现类似绿色软件。
绿化方法：
#一、注册VBoxC.dll
regsvr32 VboxC.dll

#二、注册VBoxSVC.exe
#将下面的内容保存为.reg文件，导入注册表
#需要修改X:\PATH\VBoxSVC.exe为真实路径
Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\CLSID\{B1A7A4F2-47B9-4A1E-82B2-07CCD5323C3F}
@="VirtualBox Class"
"LocalServer32"="X:\PATH\VBoxSVC.exe"
"AppID"="{819B4D85-9CEE-493C-B6FC-64FFE759B3C9}"
"ProgID"="VirtualBox.VirtualBox.1"
"TypeLib"="{46137EEC-703B-4FE5-AFD4-7C9BBBBA0259}"
"VersionIndependentProgID"="VirtualBox.VirtualBox"

#三、安装驱动VBoxDrv.sys
将DPInst.exe放到驱动目录运行一下，自动完成



sed命令批量处理二进制文件
Thu, 06 Jun 2019 17:16:02 +0000
sed 是个查找替换文本文件的工具，通常是以行为单位，关于它的用法网上有很多，但都是针对文本文件的。
sed以文本模式替换可执行文件(如exe和dll)，会导致0x0D，0x0A（换行符）被意外破坏掉，程序文件被损坏。
所以需要以二进制方式查找和替换数据，仔细研究了一下，终于有了结果，做个笔记。
其实就是加上-b参数：
一、从文件中删除指定数据
sed -b -i  ‘/\x00\x11\x22\x33/d’ demo.exe
这个命令将demo.exe文件中的00,11,22,33序列全部删掉。
二、替换文件中的数据
sed -b -i ’s/\x00\x11\x22\x33/\xAA\xBB\xCC\xDD/g’ demo.exe
这个命令将替换demo.exe文件中的00,11,22,33序列为AA,BB,CC,DD


自己制做python3.6精简绿色版
Thu, 06 Jun 2019 15:36:21 +0000
一、从官网下载完整的python3.6.8安装程序，并安装到任意目录。勾选安装pip就行，其它不用选。
二、打开安装目录，把所有文件打包到python.zip备用。
三、进入控制面板，卸载python3.6。
四、解压python.zip到任意非中文目录，开始我们的工作。
五、此时双击python.exe应该是可能正常运行的，如果没有特殊要求，其实这也算是一个绿色版python了。
六、我们可以精简掉所有的__pycache__文件夹，这个文件夹可以提高一些脚本运行速度，没有也不影响功能。
七、Scripts下面删除重复的文件：保留pip.exe，删除pip3.exe，删除pip3.6.exe，这三个其实是一模一样的文件。
八、可以删除include文件夹、可以删除Libs文件夹（这两个是python的二次开发接口SDK，用不上可以删除）。
好了，至此python精简也差不多了，基本也能写代码测试了，不过pip还不能用。原因见 上一篇文章 。
九、修复Scripts下面的EXE程序，用WinHEX打开pip.exe，拉到最后，找到下图红框内容，替换为python.exe。
注意去掉双引号，exe后面要加上0D,0A换行符，然后再加上注释符#(井号)。
下图是替换前的：

下图是替换后的：

修改完成后，保存文件，如果还有easy_install.exe也要做相同的修改。
这时再打开pip还是可能会报错，没关系，我们把python.exe的路径加入PATH环境变量就可以了。
这里有两种方式：
方式一：永久性的，直接进系统设置，修改环境变量，在PATH的最后加上python.exe的文件夹路径。
优点是全局生效，打开任意cmd窗口都可以调用python；
缺点是路径固定，如果把python移动到其它地方，则需要重新设置环境变量；
方式二：临时性的，使用批处理命令临时设置，关闭后失效。
优点是可以任意移动python的路径；
缺点是必须先打开批处理程序，利用cd命令切换到工作目录去；
我这里打包好了一个绿色版python，大家可以下载使用：
下载地址： https://download.csdn.net/download/qq446252221/11229178


PIP出现Fatal error in launcher:
Thu, 06 Jun 2019 12:49:38 +0000
在Windows命令行下面输入pip install xxx安装包时，出现Fatal error in launcher:
看提示意思是pip.exe启动时找不到启动器。
其实pip.exe就是一个打包的py脚本，运行时会自动调用python.exe来执行内部的py脚本。
报这个错的意思呢，大概就是它找不到python.exe吧。
所以我用WinHEX打开Scripts目录下面的pip.exe，一查究竟，在文件的末尾发现的关键信息：

卧槽，这家伙竟然把python.exe的绝对路径写在了pip.exe文件里！
python for windows真TM是个智障啊！
这样的python完全不具备Portable特性！
PS：我是为了避免重装系统时重复安装python，所以把安装好的python打包到了其它目录。
把它作为一个绿色软件来执行。当然要把python目录和Scripts目录加入环境变量。
然后我又检查了Scripts目录下面的所有文件，几乎所有的exe和py脚本都把python.exe的绝对路径写了上去！！！
既然python.exe已经添加到了环境变量，完全没有必要使用绝对路径，所以我试着手动修改为相对路径。
如下图所示：

保存之后，再次运行pip.exe可以正常工作了。
顺便把Scripts下面的所有文件都做了相同的修改，这样基本上还是具有Portable特性了。
把python移动到任意文件夹，并添加到环境变量PATH中，都可以正常工作。
还可以写个批处理命令，临时添加环境变量，做为python的命令行工具。
把下面的内容另存为python_cmd.bat即可
@title Python
@set PATH=%PATH%%~dp0%;
@set PATH=%PATH%%~dp0%\Scripts;
@cmd /k
后记：为了验证这个绝对路径，我又反复多次使用安装程序安装python，都是一样的。
Scripts下面的文件是在安装的时候动态修改过的，看文件修改时间就能看出来。
其它核心文件都是2018年修改，只有这几个文件是安装的日期。
因为它们在安装的时候，就把python.exe的路径给写死进去了。
这一波操作把我惊呆了！


变色龙给驱动打补丁实现USB驱动无需USBInjectAll.kext
Tue, 04 Jun 2019 13:52:07 +0000
变色龙最新版本Enoch_R2921已经有给KEXT打补丁的功能，与Clover类似，或者说是从Clover搬过来的功能。
变色龙的配置文件存放在/Extra/目录，有以下几个文件：
kernel.plist   //内核补丁配置文件
kexts.plist    //驱动补丁配置文件
org.chameleon.boot.plist //启动参数配置文件
smbios.plist   //SMBIOS机型配置文件
今天的主角是kexts.plist，利用它可以实现自动对驱动打二进制补丁和Info.plist补丁
该文件主要有几个配置项：
1.KextsPatches
这个项目下面可以添加多个驱动程序的二进制补丁，比如可以对AppleRTC，AppleHDA打补丁。
每个子项目要添加的参数有：
Comment注释内容，该内容会在启动的时候，打印到屏幕上；
MatchOS匹配的系统版本，如10.11.X，其中X表示任意数字，只有系统版本匹配才会执行补丁的内容；
Find要查找的数据，这是以Base64编码的16进制内容（建议用 plistEditor(点击下载) 查看和修改数据）；
Replace替换的数据内容，当查找到上面的数据时，将其替换为以下内容，注意数据长度要保持一致；
2.ForceToLoad
这个项目下面可以添加要强制加载的驱动程序。
目前还不知道什么情况下会用到这个。
3.PersonalitiesInjector
这个项目下面可以添加驱动注入的配置，其效果相当于直接修改某个驱动的Info.plist
应该只对目标驱动程序的配置有效。
使用方法是把目标驱动程序的Info.plist里面的复制下来，粘贴到这里面。
然后修改对应的参数，比如IONameMatch，PCIMatch等等。

最后来贴上我的配置文件以作参考：

<?xml version="1.0" encoding="UTF-8"?>
<plist version="1.0">
  <dict>
    <key>KextsPatches</key>
    <dict>
      <key>AppleRTC</key>
      <array>
        <dict>
          <key>Comment</key>
          <string>Patch AppleRTC</string>
          <key>MatchOS</key>
          <string>10.11.x</string>
          <key>Find</key>
          <data>QYnXQYn2</data>
          <key>Replace</key>
          <data>6Z8AAACQ</data>
        </dict>
      </array>
    </dict>
    <key>ForceToLoad</key>
    <array>
      <string>AppleHDA</string>
    </array>
    <key>PersonalitiesInjector</key>
    <dict>
      <key>USBInjector</key>
      <dict>
        <key>MatchOS</key>
        <string>10.11.x</string>
        <key>Comment</key>
        <string>USB EHCI Injector</string>
        <key>OSBundleRequired</key>
        <string>Root</string>
        <key>IOKitPersonalities</key>
        <dict>
          <key>MacBookPro7,1-EHC1</key>
          <dict>
            <key>CFBundleIdentifier</key>
            <string>com.apple.driver.AppleUSBMergeNub</string>
            <key>IOClass</key>
            <string>AppleUSBMergeNub</string>
            <key>IONameMatch</key>
            <string>EHC1</string>
            <key>IOProviderClass</key>
            <string>AppleUSBEHCIPCI</string>
            <key>IOProviderMergeProperties</key>
            <dict>
              <key>kUSBMuxEnabled</key>
              <true/>
            </dict>
            <key>model</key>
            <string>MacBookPro7,1</string>
          </dict>
          <key>MacBookPro7,1-EHC2</key>
          <dict>
            <key>CFBundleIdentifier</key>
            <string>com.apple.driver.AppleUSBMergeNub</string>
            <key>IOClass</key>
            <string>AppleUSBMergeNub</string>
            <key>IONameMatch</key>
            <string>EHC2</string>
            <key>IOProviderClass</key>
            <string>AppleUSBEHCIPCI</string>
            <key>IOProviderMergeProperties</key>
            <dict>
              <key>kUSBMuxEnabled</key>
              <true/>
            </dict>
            <key>model</key>
            <string>MacBookPro7,1</string>
          </dict>
        </dict>
      </dict>
    </dict>
  </dict>
</plist>



给AppleRTC打补丁防止重置BIOS
Mon, 03 Jun 2019 13:20:10 +0000
安装完黑苹果会发现BIOS设置会被重置，这是因为AppleRTC导致的，解决这个办法有几种方案：
方案一：直接在EE目录加上这个防重置驱动ElliottForceLegacyRTC.kext
这种比较稳定可靠，目前在我的电脑上测试是没有问题的。
方案二：在变色龙配置文件kext.plist里加上
这个方案在我的电脑上测试没有成功，可能与MacOS版本有关系。
方案三：手动给AppleRTC打上二进制补丁，并替换原生的AppleRTC文件
在网上找了几种补丁方案，用perl命令替换AppleRTC里面的二进制代码，结果都没有成功。
为了研究这个AppleRTC的二进制补丁，我找来了变色龙最新版本（Enoch_2921）的源代码，
在文件kernel_patcher_internal.c里发现了以下内容：
// ===================================
// (Clover)
// Patching AppleRTC to prevent CMOS reset
unsigned int AppleRTC_Patch(void *data, UInt32 DriverSize, UInt32 StartLocation)
{
    unsigned int count = 0;
    // as far as I know this works from Lion to Sierra
    UInt8   LionSearch_X64[]   = { 0x75, 0x30, 0x44, 0x89, 0xf8 };
    UInt8   LionReplace_X64[]  = { 0xeb, 0x30, 0x44, 0x89, 0xf8 };
    
    UInt8   LionSearch_i386[]  = { 0x75, 0x3d, 0x8b, 0x75, 0x08 };
    UInt8   LionReplace_i386[] = { 0xeb, 0x3d, 0x8b, 0x75, 0x08 };
    
    UInt8   MLSearch[]         = { 0x75, 0x30, 0x89, 0xd8 };
    UInt8   MLReplace[]        = { 0xeb, 0x30, 0x89, 0xd8 };
    //SunKi
    //752e0fb6 -> eb2e0fb6
    UInt8   MavSearch[]        = { 0x75, 0x2e, 0x0f, 0xb6 };
    UInt8   MavReplace[]       = { 0xeb, 0x2e, 0x0f, 0xb6};
从这部分代码能看出来，这个补丁是从Clover的代码里搬过来的，嗯有很多Clover用户也反馈RTC补丁没有作用。


使用GRUB2制作多重系统引导程序
Wed, 29 May 2019 13:40:48 +0000
装了黑苹果后，同一硬盘多个分区，有不同的系统，为了统一管理，需要找一个通用性强的引导程序。
现在环境是这样的一块硬盘，MBR分区方式，4个主分区分别如下：

  
      
          
          文件系统
          操作系统
          引导方式
      
  
  
      
          分区一(C:)
          NTFS
          Windows
          Bootmgr
      
      
          分区二(D:)
          EXT4
          Ubuntu
          linux/initrd
      
      
          分区三(E:)
          HFS+
          MacOSX
          boot(变色龙)
      
      
          分区四(F:)
          FAT32
          无
          grldr
      
  

分区四是目前只有1GB，预留用来存放通用引导程序的分区，这个分区是活动分区。
这样的分区方式，设计思想是各个分区负责引导各个分区的操作系统，互不干扰。
如果把grldr放到C盘根目录下，由Bootmgr来加载grldr，这不符合我的设计美学。
一开始我是这样思考的：
MBR设置为NT6 MBR，活动分区设置为分区四，分区四的PBR设置为GRUB4DOS。
也就是在分区四的根目录添加grldr文件和menu.lst文件，由它来引导这三个系统。
但很快就发现GRUB4DOS不支持HFS文件系统，不能读取分区三下面的/boot文件。
于是又想到了它的chainloader，用链式引导的方式，引导各个分区的PBR。
但很快又发现HFS系统的PBR很难正确地设置，还是无法引导/boot文件。
最终只能放弃GRUB4DOS。
目前能支持HFS文件系统的还是只有Chameleon和GRUB2。
优先考虑GRUB2这个引导程序。
好吧，先去下载GRUB2的内核文件，自己制作一个GRLDR吧：
下载地址： http://alpha.gnu.org/gnu/grub/
然后使用下面的命令生成一个支持HFS的core.img文件：
grub-mkimage.exe -C none -o core.img -O i386-pc -d i386-pc -p / biosdisk memdisk disk part_apple part_gpt part_msdos iso9660 udf fat exfat ntfs ext2 hfs hfsplus ls lsapm  mmap loopback net chain ntldr linux linux16 multiboot boot reboot help
这个core.img可以用GRUB4DOS的kernel命令引导，但是无法被PBR引导。


PCI设备驱动和相关知识
Mon, 27 May 2019 13:39:25 +0000
在研究黑苹果驱动时，经常会看到修改Info.plist中的IOPCIMatch字段。需要研究一下相关内容。
PCI是一种外设部件互连标准总线，和USB总线差不多，可以将不同类型的设备连接到同一条总线上。
常见的PCI设备有显卡，网卡，声卡，IDE控制器，AHCI控制器，USB控制器等。
符合PCI标准的设备，都必须有一个VID和DID，在Windows设备管理器中，可以很方便地查看设备的硬件ID。
下图以网卡为例：

设备ID以PCI开头，表示这是PCI设备，VEN_10EC&DEV_8168，表示设备的VID=0x10EC，DID＝0x8168。
VID是标识厂商的唯一代码，不同厂商是不同的，由一个神秘组织维护这些VID。知道VID就知道厂商名称。
比如0x10EC是RealTek，0x10DE是Nvidia，0x8086是Intel。
DID是标识不同的设备代码，相同厂商有不同和设备，需要用DID来区分。
比如这里的0x8168就是Realtek的以太网卡设备，Realtek还有声卡等其它设备，具有不同的DID。
一般情况下用VID和DID就可以匹配设备驱动程序了。
除此之外，还有Subsystem ID和Revision ID和Class Code。
Subsystem ID是次要的设备识别码，作用与VID和DID相同，长度为4字节。
Revision ID是版本号，长度为1字节。
Class Code是设备类型代码，由神秘组织定义的设备类型代码，长度为3字节。
关于设备类型代码，在这里有说明： http://pci-ids.ucw.cz/read/PD
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
大概了解了PCI设备的知识后，再来看看Windows驱动程序，Windows驱动一般由一个sys文件和inf文件组成。
inf描述了设备驱动程序的安装过程，以及对应的设备ID。
我找来了刚才的网卡驱动，找到里面关于设备ID的字段如下（部分内容）：
;8168B
%RTL8168.DeviceDesc%    = RTL8168.ndi,      PCI\VEN_10EC&DEV_8168&REV_01
%RTL8168.DeviceDesc%    = RTL8168.ndi,      PCI\VEN_10EC&DEV_8168&SUBSYS_816810EC&REV_01
;8112
%RTL8112.DeviceDesc%    = RTL8168.ndi,      PCI\VEN_10EC&DEV_8168&SUBSYS_83851043&REV_01

;8168D
%RTL8168D.DeviceDesc%   = RTL8168D.ndi,     PCI\VEN_10EC&DEV_8168&REV_03
%RTL8168D.DeviceDesc%   = RTL8168D.ndi,     PCI\VEN_10EC&DEV_8168&SUBSYS_816810EC&REV_03
;8112L
%RTL8112L.DeviceDesc%   = RTL8168D.ndi,     PCI\VEN_10EC&DEV_8168&SUBSYS_83A31043&REV_03

;8168E
%RTL8168E.DeviceDesc%   = RTL8168E.ndi,     PCI\VEN_10EC&DEV_8168&REV_06
%RTL8168E.DeviceDesc%   = RTL8168E.ndi,     PCI\VEN_10EC&DEV_8168&SUBSYS_816810EC&REV_06
从这里可以看出来，当设备的VID和DID是相同的时候，还需要由SUBSYS和REV来区分不同的版本。
Windows安装驱动程序的时候，会检测到我的网卡ID符合下面这条内容：
%RTL8168E.DeviceDesc%   = RTL8168E.ndi,     PCI\VEN_10EC&DEV_8168&REV_06
因此会为我的网卡安装这个驱动程序。


黑苹果日记六（双系统引导）
Sat, 25 May 2019 14:13:51 +0000
打算把MAC OS X和Win7装到同一块硬盘的不同分区，所以要研究一下变色龙的引导程序。
目前变色龙原版最新只更新到V2.4_R2877版本,后面的版本是它的分支Enoch_V2.4_R2921。
MBR引导时，一般是用grldr来装载wowpc.iso来进入变色龙程序。
wowpc.iso是一个可引导的光盘镜像，而且是一个Hybrid/ISO混合模式的镜像，用UltroISO不能原样保存。
打开wowpc.iso里面也没有几个文件，试着解压出来，用grldr直接引导里面的boot文件，似乎也可以。
不过没有GUI界面了，变成了BIOS默认的文本显示方式。
这个boot程序会自动扫描HFS格式的磁盘，然后列表显示出来让你选择要从哪个磁盘启动。
如果没猜错的话，那应该可以用GRUB4DOS来做双系统引导了。
附上GRUB4DOS的引导命令：
#引导Windows
chainloader /Bootmgr
boot

#引导变色龙的wowpc.iso
map /wowpc.iso (hd32)
map --hook
chainloader (hd32)
boot

#引导变色龙的boot
#注意这个boot文件与windows系统的boot目录重名了，最好改为其它文件名。
kernel /boot
boot
另外，在黑白界面的变色龙程序里找到了内置的帮助文档，发现它的配置参数还是不少。
管它用得上用不上，先复制出来做个记录保存一下：
The boot: prompt waits for you to type advanced startup options.
If you don't type anything, the computer continues starting up normally. It
uses the kernel and configuration files on the startup device, which it also
uses as the root device.

Advanced startup options use the following syntax:

    [device]<kernel> [arguments]

Example arguments include

 device: rd=<BSD device name>       (e.g. rd=disk0s2)
         rd=*<IODeviceTree path>    (e.g. rd=*/PCI0@0/CHN0@0/@0:1)

 kernel: kernel name                (e.g. "mach_kernel" - must be in "/" )

 flags: -v (verbose),                -s (single user mode),
        -x (safe mode),              -f (ignore caches),
        -F (ignore "Kernel Flags" specified in boot configuration file)

 "Graphics Mode"="WIDTHxHEIGHTxDEPTH" (e.g. "1024x768x32")

 kernel flags                       (e.g. debug=0x144)
 io=0xffffffff                      (defined in IOKit/IOKitDebug.h)

Example: mach_kernel rd=disk0s1 -v "Graphics Mode"="1920x1200x32"

If the computer won't start up properly, you may be able to start it up using
safe mode.  Type -x to start up in safe mode, which ignores all cached
driver files.

Special booter hotkeys:
-----------------------
  F5            Rescans optical drive.
  F10           Scans and displays all BIOS accessible drives.

Special booter commands:
------------------------
  ?memory       Displays information about the computer's memory.
  ?video        Displays VESA video modes supported by the computer's BIOS.
  ?norescan     Leaves optical drive rescan mode.

Additional useful command-line options:
---------------------------------------
  config=<file>             Use an alternate Boot.plist file.

Options useful in the org.chameleon.Boot.plist file:
----------------------------------------------------
  Wait=Yes|No               Prompt for a key press before starting the kernel.
  "Quiet Boot"=Yes|No       Use quiet boot mode (no messages or prompt).
  Timeout=8                 Number of seconds to pause at the boot: prompt.
  "Instant Menu"=Yes        Force displaying the partition selection menu.

  "Default Partition"     Sets the default boot partition,
    =hd(x,y)|UUID|"Label"    Specified as a disk/partition pair, an UUID, or a
                             label enclosed in quotes.

  "Hide Partition"        Remove unwanted partition(s) from the boot menu.
    =partition               Specified, possibly multiple times, as hd(x,y), an
     [;partition2 ...]       UUID or label enclosed in quotes.

  "Rename Partition"      Rename partition(s) for the boot menu.
    =partition <alias>       Where partition is hd(x,y), UUID or label enclosed
     [;partition2 <alias2>   in quotes. The alias can optionally be quoted too.
     ...]

  GUI=No                  Disable the GUI (enabled by default).
  "Boot Banner"=Yes|No    Show boot banner in GUI mode (disabled by default).
  ShowInfo=No             Disables display of partition and resolution details.
                            "Boot Banner"=No will also disable this info.
  "Legacy Logo"=Yes|No    Use the legacy grey apple logo (enabled by default).

  RebootOnPanic=Yes|No    (disabled by default).

  EnableHiDPI=Yes|No      Enable High resolution display (disabled by default).

  BlackMode=Yes|No        The new BlackMode loads the white Apple logo,
                             instead of the gray Apple logo, on a black background (disabled by default).

  CsrActiveConfig=<value> Set CsrActiveConfig for OS 10.11.x, range 0..255 (default 0x67)

  PciRoot=<value>         Use an alternate value for PciRoot (default value 0).

  UseKernelCache=Yes|No   Yes will load pre-linked kernel and will ignore /E/E
						    and /S/L/E/Extensions.mkext.
							Default is No but Yes if you use Lion on a Raid partition.

  KeyLayout=keymap        Use to change the keyboard mapping of the bootloader
                            (e.g. KeyLayout=mac-fr)

  HDAEnabler=Yes|No         Automatic device-properties generation for audio controllers.
    HDEFLayoutID=<value>    Inject alternate value of layout-id for HDEF (HEX).
    HDAULayoutID=<value>    Inject alternate value of layout-id for HDAU (HEX).

  GraphicsEnabler=Yes|No    Automatic device-properties generation for graphics cards.
    SkipIntelGfx=Yes|No     Skip the Automatic device-properties generation for Intel cards.
    SkipNvidiaGfx=Yes|No    Skip the Automatic device-properties generation for Nvidia cards.
    SkipAtiGfx=Yes|No       Skip the Automatic device-properties generation for Ati cards.

    NvidiaGeneric=Yes|No    Use the classic Nvidia name for the SystemProfiler (disabled by default).
    NvidiaSingle=Yes|No     If you have two cards Nvidia and wants to inject only
                              first one then you can set this parameter (enbaled by default).
    NvidiaNoEFI=Yes|No      Inject NVDA,noEFI value as true

    AtiConfig=<cardcfg>   Use a different card config, e.g. AtiConfig=Megalodon.
    AtiPorts=<value>      Specify the number of ports, e.g. AtiPorts=2.
    UseAtiROM=Yes|No      Use an alternate Ati ROM image
                            (default path: /Extra/<vendorid>_<devid>_<subsysid>.rom)
    UseNvidiaROM=Yes|No   Use an alternate Nvidia ROM image
                            (default path:  /Extra/<vendorid>_<devid>.rom)
    VBIOS=Yes|No            Inject VBIOS to device-properties.
    display_0=<value>       Inject alternate value of display-cfg into NVDA,Display-A@0 (HEX).
    display_1=<value>       Inject alternate value of display-cfg into NVDA,Display-B@1 (HEX).
    IntelCapriFB=<value>    For Intel Ivy Bridge, range 0-11.
    IntelAzulFB=<value>     For Intel Haswell, range 0-16.
    IntelBdwFB=<value>      For Intel Broadwell, range 0-19.
    IntelSklFB=<value>      For Intel Skylake, range 0-12.
    InjectIntel-ig=<value>  Inject alternate value into AAPL,ig-platform-id (HEX).

    EnableBacklight=Yes	  Enable Back light option for NVIDIA and ATI
    EnableDualLink=Yes	  Enable DualLink option for NVIDIA and ATI
    EnableHDMIAudio=Yes	  Inject HDMI audio for NVIDIA and ATI.

  EthernetBuiltIn=Yes|No  Automatic "built-in"=YES device-properties generation
                          for ethernet interfaces.
  ForceHPET=Yes|No        Force HPET on (disabled by default).

  USBBusFix=Yes             Enable the XHCI, EHCI and UHCI fixes (disabled by default).
  EHCIacquire=Yes           Enable the EHCI fix (disabled by default).
  UHCIreset=Yes             Enable the UHCI fix (disabled by default).
  USBLegacyOff=Yes          Force USB Legacy off for XHCI and EHCI (disabled by default).
  XHCILegacyOff=Yes         Force USB Legacy off for XHCI (disabled by default).

  Wake=No                   Disable wake up after hibernation (enbaled by default).
  ForceWake=Yes             Force using the sleepimage (disabled by default).
  WakeImage=<file>          Use an alternate sleepimage file 
                              (default path is /private/var/vm/sleepimage).

  DropSSDT=Yes              Skip the SSDT tables while relocating the ACPI tables.
  Drop<file>=Yes            Skip:[HPET, SLIC, SBST, ECDT, ASF! or DMAR]

  DSDT=<file>               Use an alternate DSDT.aml file 
                              (default path: /DSDT.aml
                               /Extra/DSDT.aml bt(0,0)/Extra/DSDT.aml).
  HPET=<file>               Use an alternate HPET.aml file 
                              (default path: /HPET.aml
                               /Extra/HPET.aml bt(0,0)/Extra/HPET.aml).
  SBST=<file>               Use an alternate SBST.aml file 
                              (default path: /SBST.aml
                               /Extra/SBST.aml bt(0,0)/Extra/SBST.aml).
  ECDT=<file>               Use an alternate ECDT.aml file 
                              (default path: /ECDT.aml
                               /Extra/ECDT.aml bt(0,0)/Extra/ECDT.aml).
  ASFT=<file>               Use an alternate ASFT.aml file 
                              (default path: /ASFT.aml
                               /Extra/ASFT.aml bt(0,0)/Extra/ASFT.aml).
  DMAR=<file>               Use an alternate DMAR.aml file 
                              (default path: /DMAR.aml
                               /Extra/DMAR.aml bt(0,0)/Extra/DMAR.aml).
  APIC=<file>               Use an alternate APIC.aml file 
                              (default path: /APIC.aml
                               /Extra/APIC.aml bt(0,0)/Extra/APIC.aml).
  MCFG=<file>               Use an alternate MCFG.aml file 
                              (default path: /MCFG.aml
                               /Extra/MCFG.aml bt(0,0)/Extra/MCFG.aml).
  FADT=<file>               Use an alternate FADT.aml file 
                              (default path: /FADT.aml
                               /Extra/FADT.aml bt(0,0)/Extra/FADT.aml).

  GenerateCStates=Yes     Enable auto generation of processor idle sleep states
                            (C-States).
  GeneratePStates=Yes     Enable auto generation of processor power performance
                            states (P-States).
  CSTUsingSystemIO=Yes    New C-State _CST generation method using SystemIO
                            registers instead of FixedHW.

  EnableC2State=Yes       Enable specific Processor power state, C2.
  EnableC3State=Yes       Enable specific Processor power state, C3.
  EnableC4State=Yes       Enable specific Processor power state, C4.
  EnableC6State=Yes       Enable specific Processor power state, C6.
  EnableC7State=Yes       Enable specific Processor power state, C7.

  PrivateData=No          Show masked data (serial number) in bdmesg log (enbaled by default).

  ForceFullMemInfo=Yes    Force SMBIOS Table 17 to be 27 bytes long (disabled by default).

  SMBIOS=<file>             Use an alternate SMBIOS.plist file
                              (default path: /smbios.plist /Extra/smbios.plist
                               bt(0,0)/Extra/smbios.plist).

  SMBIOSdefaults=No         Don't use the Default values for SMBIOS overriding
                              if smbios.plist doesn't exist, factory
                              values are kept.


  KERNELPlist=<file>        Use an alternate kernel.plist file
                              (default path: /Extra/Kernel.plist
                               bt(0,0)/Extra/kernel.plist).

  KEXTPlist=<file>          Use an alternate kext.plist file
                              (default path: /Extra/Kext.plist
                               bt(0,0)/Extra/kext.plist).

  "Scan Single Drive"       Scan the drive only where the booter got loaded from.
    =Yes|No                 Fix rescan issues when using a DVD reader in AHCI mode. 
  Rescan=Yes                Enable CD-ROM rescan mode.
  "Rescan Prompt"=Yes       Prompts for enable CD-ROM rescan mode.
  SystemId=<UUID>         Set the system id manually to UUID.
                              Deprecated - Now SMsystemuuid in smbios.plist
                          SMUUID in smbios config (reserved field) isn't used then.
  SystemType=<n>          Set the system type to n, where n is between 0..6
                          (default=1 Desktop)
  md0=<file>              Load raw img file into memory for use as XNU's md0
                          ramdisk. /Extra/Postboot.img is used otherwise.
 



黑苹果日记五（USB）
Thu, 23 May 2019 16:59:48 +0000
设定为SMBios中的机型后，该研究一下USB接口的问题了。
之前加了USBInjectAll.kext还是有作用的，可以驱动所有USB口。
原生的USB驱动文件在以下目录：/S/L/E/IOUSBHostFamily.kext/Contents/PlugIns/AppleUSBEHCIPCI.kext
打开下面的Contents/Info.plist，可以找到一堆与机型相关的配置。
结合之前部分USB接口能用的现象，反复观察后，认为与下面的内容有关：
<key>MacBookPro7,1-EHC1</key>
		<dict>
			<key>CFBundleIdentifier</key>
			<string>com.apple.driver.AppleUSBMergeNub</string>
			<key>IOClass</key>
			<string>AppleUSBMergeNub</string>
			<key>IONameMatch</key>
			<string>EHC1</string>
			<key>IOProviderClass</key>
			<string>AppleUSBEHCIPCI</string>
			<key>IOProviderMergeProperties</key>
			<dict>
				<key>port-count</key>
				<data>
				BgAAAA==
				</data>
				<key>ports</key>
				<dict>
					<key>PRT1</key>
					<dict>
						<key>UsbConnector</key>
						<integer>0</integer>
						<key>port</key>
						<data>
						AQAAAA==
						</data>
					</dict>
					<key>PRT6</key>
					<dict>
						<key>UsbConnector</key>
						<integer>255</integer>
						<key>port</key>
						<data>
						BgAAAA==
						</data>
					</dict>
				</dict>
			</dict>
			<key>model</key>
			<string>MacBookPro7,1</string>
		</dict>
		<key>MacBookPro7,1-EHC2</key>
		<dict>
			<key>CFBundleIdentifier</key>
			<string>com.apple.driver.AppleUSBMergeNub</string>
			<key>IOClass</key>
			<string>AppleUSBMergeNub</string>
			<key>IONameMatch</key>
			<string>EHC2</string>
			<key>IOProviderClass</key>
			<string>AppleUSBEHCIPCI</string>
			<key>IOProviderMergeProperties</key>
			<dict>
				<key>port-count</key>
				<data>
				BgAAAA==
				</data>
				<key>ports</key>
				<dict>
					<key>PRT1</key>
					<dict>
						<key>UsbConnector</key>
						<integer>255</integer>
						<key>port</key>
						<data>
						AQAAAA==
						</data>
					</dict>
					<key>PRT3</key>
					<dict>
						<key>UsbConnector</key>
						<integer>255</integer>
						<key>port</key>
						<data>
						AwAAAA==
						</data>
					</dict>
					<key>PRT4</key>
					<dict>
						<key>UsbConnector</key>
						<integer>0</integer>
						<key>port</key>
						<data>
						BAAAAA==
						</data>
					</dict>
					<key>PRT5</key>
					<dict>
						<key>UsbConnector</key>
						<integer>255</integer>
						<key>port</key>
						<data>
						BQAAAA==
						</data>
					</dict>
					<key>PRT6</key>
					<dict>
						<key>UsbConnector</key>
						<integer>255</integer>
						<key>port</key>
						<data>
						BgAAAA==
						</data>
					</dict>
				</dict>
			</dict>
			<key>model</key>
			<string>MacBookPro7,1</string>
		</dict>
其中EHC1和EHC2即是本机的USB控制器名称，在Windows系统下用USBTree工具查看USB设备信息如下：


黑苹果日记四（SMBIOS）
Thu, 23 May 2019 13:16:50 +0000
已知SMBios.plist的设置对于USB驱动有一定帮助，除此之外，这些信息还会展示在关于信息里面。
所以有必要了解一下苹果的产品线及其代码。
目前苹果电脑产品线包括：iMac、iMacPro、MacPro、MacMini、Macbook、Macbook Air、MacbookPro
iMac和iMacPro都是桌面电脑，主机显示器一体机。带Pro表示功能更多，性能更强大。
MacMini和MacPro是桌面电脑的主机，不含显示器。带Pro表示功能更多，性能更强大。
Macbook 是轻便超薄型笔记本，老款从2006年到2011年就断货了，直到2015年又出了新的Macbook，有点不明白。
Macbook Air也是轻便超薄型，使用Intel低主频CPU和集成显卡，和2015年以后的Macbook定位好像是一样的？
Macbook Pro则是高性能笔记本了，带Pro表示功能更多，性能更强大。配置高主频CPU和独立显卡。
对于不同的机型，苹果提供了相关机型识别，可以查看机型标识符和基本配置信息：
iMac： https://support.apple.com/zh-cn/HT201634
Mac Pro： https://support.apple.com/zh-cn/HT202888
Mac Mini： https://support.apple.com/zh-cn/HT201894
Macbook： https://support.apple.com/zh-cn/HT201608
Macbook Air： https://support.apple.com/zh-cn/HT201862
Macbook Pro： https://support.apple.com/zh-cn/HT201300
简单阅览过后发现，一些2010年左右的老机型，最新兼容操作系统写着10.11.6，再新一点的电脑也只兼容10.13.6。
看来我的老笔记本估计也只能装10.11.6版本了，2010年的本子差不多都是这个配置。
最后觉得Macbook (13寸，2010年中)，部件号：MC516xx/A，标识符为：Macbook7,1
还有Macbook Pro (13 英寸, 2010 年中)，部件号：MC374CH/A，标识符为：MacbookPro7,1
这两个型号与我的笔记本配置比较相近，连分辨率都是相同的1280*800呢，显卡也是同时代的NV3xxM系列。
SMBIOS参考配置如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>SMbiosdate</key>
	<string>03/25/10</string>
	<key>SMbiosvendor</key>
	<string>Apple Inc.</string>
	<key>SMbiosversion</key>
	<string>MBP71.88Z.0039.B05.1003251322</string>
	<key>SMboardproduct</key>
	<string>Mac-F222BEC8</string>
	<key>SMfamily</key>
	<string>MacBook</string>
	<key>SMmanufacter</key>
	<string>Apple Inc.</string>
	<key>SMmanufacturer</key>
	<string>Apple Inc.</string>
	<key>SMproductname</key>
	<string>MacBookPro7,1</string>
	<key>SMserial</key>
	<string>W80140U3ATM</string>
	<key>SMsystemversion</key>
	<string>1.0</string>
</dict>
</plist>
最后附上网上找到的相关SMBios信息：


nRF52832+FreeRTOS发现一处罕见的死机(HardFalut)问题
Thu, 23 May 2019 11:45:24 +0000
前言
开发nRF52832程序，由于之前的代码是基于裸机程序开发的，使用app_timer和app_sched来调度任务。
但由于项目中有一个功能对任务实时性有需求，所以移植了freeRTOS，用一个单独的高优先级线程处理这个高实时性要求的任务。
为了提高代码复用性，尽量不改动现有的基于app_timer机制的代码。
所以在freeRTOS环境下，要实现app_timer和app_sched的功能，nodic的SDK中已经有了app_timer_freertos.c。
但app_sched模块还没有，所以需要自行实现这个模块，可以创建一个低优先级线程和一个队列来实现此功能。
官方提供的app_time_freertos并没有使用app_timer_appsh，这样一来app_timer和app_sched处于不同的工作线程，
app_timer的回调函数和app_sched的回调函数存在竞争风险，因此需要修改app_time_freertos，使其调用app_timer_appsh模块。
由app_timer_appsh模块把定时器事件放入app_sched来调用。
正文
好了，大功告成，原先的代码基本不用修改，就能在freeRTOS下面运行了。
然而，程序刚运行就出现了HardFault，只好打开DEBUG寻找原因。
发现代码最后死在了app_timer_appsh.c里面，这里面代码很少，先帖上来。
#include "app_timer_appsh.h"
#include "app_scheduler.h"

static void app_timer_evt_get(void * p_event_data, uint16_t event_size)
{
    app_timer_event_t * p_timer_event = (app_timer_event_t *)p_event_data;

    APP_ERROR_CHECK_BOOL(event_size == sizeof(app_timer_event_t));
    p_timer_event->timeout_handler(p_timer_event->p_context);
}

uint32_t app_timer_evt_schedule(app_timer_timeout_handler_t timeout_handler,
                                void *                      p_context)
{
    app_timer_event_t timer_event;

    timer_event.timeout_handler = timeout_handler;
    timer_event.p_context       = p_context;

    return app_sched_event_put(&timer_event, sizeof(timer_event), app_timer_evt_get);
}
问题就出在app_timer_evt_get这个函数，以为是指针错误？指针越界？长度错误？指针指向的内存数据不正确？
NO！ NO！NO！  都不是！！！
这里的参数p_event_data和下面app_timer_evt_schedule保存进去的内容是完全一致的，没有任何问题。
通过查看反汇编代码，单步跟踪运行，发现最后程序在执行LDRD指令的时候，直接就挂了。如下图：

反复测试，都是死在LDRD这条指令上面。
而LDRD指令是干什么的呢？
它是一条加载64位数据的指令。
如图中所示：LDRD r1,r0,[r6,#0]。
表示从R6+0这个地址加载一个64位的整数，并把低32位放入R1，高32位放入R0。
R6是p_timer_event，是个结构体指针，这个结构体刚好是8字节（64位），
低32位就是函数指针p_timer_event->timeout_handler。


黑苹果日记三（驱动）
Wed, 22 May 2019 16:55:13 +0000
继上次解决了USB和有线网卡的问题后，又继续找资料尝试解决显卡，声卡，无线网卡的问题。
一、由于无线网卡是BCM43XX，且设备ID为PCI：14E4：4727
据说目前全球无解，所以只好放弃了。
二、声卡也是IDT 92HD81B1C5系列，设备ID为 PCI：111D：76D5
好像也很难搞，最后用万能声卡驱动VoodooHDA了，声音很小，耳机声音正常，但是无法正常调节音量。
直接把VoodooHDA.kext放到EE目录没有驱动成功。
后来找到VoodooHDA的MAC版的安装程序，自动安装完成的，还附带了几个PCI工具和HWmonitor。
三、显卡是NVS3100M，设备ID为PCI：10DE：0A6C
这个显卡好像可以免驱？但是我这边确又驱动不正常。
在变色友配置里开启GraphicsEnabler=Yes，进入系统可以看到正确地识别出了显卡型号，但是还是没有驱动上。
在EE目录添加NVEnabler64.kext，没有任何作用。
回头想想好像NV的显卡驱动不是被我删除了么？
SLE目录下面没有NV开头的文件，所以找回这些文件放回SLE重启，还是一样。
折腾了很久，没有成功。最后打算重新安装一次系统。
这次在安装的时候不删除NV的驱动，开启变色龙的GraphicsEnabler=Yes，哈哈可以正常进入安装界面，显卡自动驱动上了。
哈哈哈，这真是太好了，进入系统后不会滚屏了，屏保也能正常使用了。感觉驱动是正常了。666！


黑苹果日记二（驱动）
Tue, 21 May 2019 17:48:14 +0000
继上一次安装黑苹果(10.11懒人版)成功进入桌面后，除了笔记本内置的键盘和触摸板以外，其它任何驱动都没有成功。
没有声音，没有网络，没有USB，没有显卡！
更严重的是每次重启，发现电脑的BIOS设置被重置了， 这个感觉很严重。
上网爬各种帖子，寻找解决方案。
终于解决了一些问题：
一，重置BIOS的问题
上网找ElliottForceLegacyRTC.kext放到EE目录，由变色龙注入到系统。解决BIOS重置的问题。
二、板载intel有线网卡驱动
上网找到IntelMausiEthernet.kext放到EE目录，重启电脑发现有线网卡可以用了！
三，USB驱动

上网找了USBInjectAll.kext，放到EE目录，没有作用。

2.修改变色龙配置，USBBusFix=Yes，没有作用。
3.听说要修改DSDT，于是又找了DSDT的软件，找到电脑的USB接口信息，命名为EHC1和EHC1，好像没有问题？
4.继续找帖子，说USB2.0驱动，可以修改以下驱动文件的信息：
/System/Library/Extensions/IOUSBHostFamily.kext/Contents/PlugIns/AppleUSBEHCIPCI.kext/Contents/Info.plist
研究了一下这个文件，找到了一些关于USB接口的描述，好像与机型有关，
这个机型设置来源于变色龙的配置文件smbios.plist，默认机型是iMac14,1，而这个机型对应的USB接口描述好像是空的。
于是修改机型为Macpro5,1，重启系统，发现USB鼠标竟然可以动了，真是惊喜！
测试了一下笔记本的所有USB接口设备都能用，就连USB蓝牙，USB读卡器也都驱动了，真是太好了！！！
5.USBInjectAll.kext到底有没有作用呢，删除这个文件，再重启电脑，发现只有一部分USB口可以用。
6.把变色龙配置USBBusFix改为No看看，和第5点一样，说明这个修改这个配置项对我的笔记本是无效的。
四、声卡，显卡，无线网卡还有没成功，待续。。。


黑苹果日记（安装）
Mon, 20 May 2019 16:03:59 +0000
2010年的闲置老笔记本，用来试试能不能装个黑苹果，在此记录一下安装笔记。
CPU: intel i3-380m
主板：HM55
RAM:4GB DDR3
GPU: Nvidia NVS3100M
LCD:1280*800
从零开始：
最开始听说MAC OS只能用EFI和GPT，后来知道MBR也可以，要用懒人版CDR镜像。
尽量用懒人版镜像吧，安装会简单得多！
引导方式有两种，一种是变色龙（Chameleon）,另一种是四叶草(Clover)。
MBR引导建议用变色龙单，UEFI引导建议用四叶草。
四叶草配置复杂，变色龙配置简单。
CDR镜像可以用7zip打开，可以看到里面有一个Extra目录，下面有org.chameleon.Boot.plist和Extensions目录
Extensions目录下面存放了FakeSMC.kext等一些外置驱动，这是黑苹果必须的文件。
/Extra/Extensions目录被大家简称为EE目录，这是引导器注入到系统的驱动。
/System/Library/Extensions目录被简称为SLE目录，这是苹果官方的驱动。
变色龙引导：
变色龙的引导程序就是wowpc.iso，需要使用grub4dos来启动，如何引导grldr就不说了，
说一下变色龙的启动命令，一般添加到menu.lst中
map /wowpc.iso (hd32)
map --hook
chainloader (hd32)
boot
变色龙启动后，它会搜索系统硬盘，找出可以引导的磁盘，包括Windows,Linux,MAC OS X系统。
制作黑苹果安装盘：
MAC OS使用的文件系统是HFS+，并不能在Windows中直接访问，但可以用一些工具来实现。
HFS+ for windows: 这个工具可以使Windows识别到HFS文件系统的磁盘，很有用，安装过程中需要用它来删除/增加文件。
TransMac.exe: 这个工具是用来制作U盘安装盘的，它可以把dmg和cdr镜像写入U盘，从U盘中安装黑苹果。
安装过程中可能出现Still waiting for root device!， 因为没有USB驱动的情况下，识别不到这个U盘。
ddmac.exe:这个工具是用来制作硬盘安装盘的，它可以把dmg和cdr镜像写入硬盘的某个分区，不破坏硬盘的原有分区。
需要注意写完镜像后，检查分区标识是否成功修改为AF，没有的话要自己手动修改一下。
推荐使用硬盘安装！
安装系统前准备工作：
制作好硬盘镜像后，要用HFS+工具读取该磁盘的文件内容：
一定要检查EE目录是否有以下文件：
FakeSMC.kext 黑苹果核心文件。
VoodooPS2Controller.kext 笔记本内置键盘和触摸板的驱动，否则进入安装界面也操作不了。
USBInjectAll.kext 据说可以驱动大部分电脑的USB端口。
一定要检查SLE目录要删除以下文件：
AMD开头
NV开头
AppleThunderbolt*
AppleIntelCPUPower*
AppleIntelGraphics*
开始安装：
重启电脑，进入变色龙，选择最后面的那个苹果标志的磁盘，因为第一个是假的，启动不了的。


JLinkARM.dll部分导出函数定义
Mon, 06 May 2019 11:41:17 +0000
JLink未对个人开放软件开发接口(SDK)，无法进行二次开发，但通过研究发现，大部分接口都在JLinkARM.dll中实现。
JLinkARM是JLink调试器对ARM系列CPU的JTAG/SWD访问接口。
有了JLinkARM.dll的函数接口，我们就可以利用它进行2次开发，实现一些特定的功能，比如自定义烧录工具等。
以下是导出函数的原型（部分）：
//JLINK TIF
#define JLINK_TIF_JTAG          0
#define JLINK_TIF_SWD           1

//RESET TYPE
#define JLINK_RESET_TYPE_NORMAL 0
#define JLINK_RESET_TYPE_CORE   1
#define JLINK_RESET_TYPE_PIN    2

//REGISTER INDEX
/* 
  0 - 15     R0 - R15(SP=R13, PC=R15)
 16          XPSR
 17          MSP
 18          PSP
 19          RAZ
 20          CFBP
 21          APSR
 22          EPSR
 23          IPSR
 24          PRIMASK
 25          BASEPRI
 26          FAULTMASK
 27          CONTROL 
 28          BASEPRI_MAX
 29          IAPSR
 30          EAPSR
 31          IEPSR
 */

void  (WINAPI *JLINK_SetLogFile)(char *file);
DWORD (WINAPI *JLINK_GetDLLVersion)(void);
DWORD (WINAPI *JLINK_GetHardwareVersion)(void);
DWORD (WINAPI *JLINK_GetFirmwareString)(char *buff, int count);
DWORD (WINAPI *JLINK_GetSN)(void);

BOOL  (WINAPI *JLINK_ExecCommand)(char* cmd, int a, int b);
DWORD (WINAPI *JLINK_TIF_Select)(int type);
void  (WINAPI *JLINK_SetSpeed)(int speed);
DWORD (WINAPI *JLINK_GetSpeed)(void);
DWORD (WINAPI *JLINK_GetId)(void);
DWORD (WINAPI *JLINK_GetDeviceFamily)(void);

BOOL  (WINAPI *JLINK_Open)(void);
void  (WINAPI *JLINK_Close)(void);
BOOL  (WINAPI *JLINK_IsOpen)(void);

BOOL  (WINAPI *JLINK_Connect)(void);
BOOL  (WINAPI *JLINK_IsConnected)(void);
int   (WINAPI *JLINK_Halt)(void);
BOOL  (WINAPI *JLINK_IsHalted)(void);
void  (WINAPI *JLINK_SetResetType)(int type);
void  (WINAPI *JLINK_Reset)(void);
void  (WINAPI *JLINK_Go)(void);
void  (WINAPI *JLINK_GoIntDis)(void);
DWORD (WINAPI *JLINK_ReadReg)(int index);
int   (WINAPI *JLINK_WriteReg)(int index, DWORD data);

int   (WINAPI *JLINK_ReadMem)(DWORD addr, int len, void *buf);
int   (WINAPI *JLINK_WriteMem)(DWORD addr, int len, void *buf);
int   (WINAPI *JLINK_WriteU8)(DWORD addr, BYTE data);
int   (WINAPI *JLINK_WriteU16)(DWORD addr, WORD data);
int   (WINAPI *JLINK_WriteU32)(DWORD addr, DWORD data);

int   (WINAPI *JLINK_EraseChip)(void);
int   (WINAPI *JLINK_DownloadFile)(LPCSTR file, DWORD addr);
void  (WINAPI *JLINK_BeginDownload)(int index);
void  (WINAPI *JLINK_EndDownload)(void);
之所以定义成函数指针，是为了使用Windows API函数GetProcAddress来获取该函数的地址。


不安装iTunes实现USB数据线与电脑传文件
Tue, 30 Apr 2019 17:22:57 +0000
苹果手机需要安装iTunes才能与其设备进行USB通信，诸如查看设备信息，管理联系人，管理照片，管理应用程序等众多功能。
但iTunes软件在Windows上使用体验极度不好，况且大部分情况下，安装iTunes只是为了用USB向手机传文件。
说到USB传文件，还必须要手机内的APP开放了文件共享权限，才能通过iTunes访问应用程序内的文件数据。
其传输速度在USB 2.0的电脑上，可以达到20－25MB/s，用来传下载好的电影还算不错。
另外，其实只是传文件的话，国产软件iTools、爱思助手等软件使用其来更加方便，但是它们依然需要调用iTunes提供的接口，
因此必须要在电脑上安装iTunes相关的组件，才能实现USB通信。
但是安装iTunes会在系统里创建无数个开机自启服务，安装包体积也是足够臃肿，实在有点不舒服。
解开iTunes的安装包，还会发现它内部其实要安装以下四个程序组件，分别是：
1.AppleApplicationSupport.msi（41MB） 苹果软件支持组件，为苹果其它软件提供运行环境。
2.AppleMobileDeviceSupport.msi（10MB） 苹果设备支持组件，包含USB驱动和一堆设备通信相关工具。
3.Bonjour.msi（2MB）苹果为基于组播域名服务(multicast DNS)的开放性零设置网络。
4.iTunes.msi（73MB）iTunes应用程序。
实际上只需要安装1和2就可以实现用iTools和爱思助手来管理苹果手机了。
即使只安装1和2，还是会增加好几个开机服务，你可以在任务管理器进程列表里看到它们的身影。
对于强迫症患者来说，还是有点不可接受，难道就没有比这更简洁的办法了吗？
答案是有的！
主要实现方法还是要靠手机里的文件管理类APP，比如Documents、MFiles等支持HTTP,FTP方式传文件的软件。
这类手机APP还可以对文件进行重命名，压缩，解压等操作，然后再通过APP内分享文件的方式，导入到其它APP里！
并且HTTP和FTP方式都不需要在电脑上安装任何软件就可以实现双向通信，可以说是非常简洁了，简直就是强迫症的福音！
使用方法也很简单，只要手机和电脑连接同一个WIFI就能通信，如果此地没有WIFI可用，那么还可以使用手机开个热点，或者电脑开热点的方法制造WIFI，最后打开手机上的APP，在电脑上用浏览器输入对应的IP地址和端口就可以了！
然而，这个方法的弊端还是很明显:
第一、如果电脑没有无线网卡，连接不了WIFI，那就不行了。
第二、使用WIFI的通信速度远不如USB传输，在2.4G WIFI环境下大概只有1－2MB/s的速度，传大文件效率很低。
那么有没有用USB又不安装iTunes的方法呢？
答案是有的！
那是因为苹果手机开热点，不仅可以开WIFI热点，还可以开一个USB热点！
当你用USB连接电脑的时候打开手机热点，你有没有发现电脑上会出现一个Apple Mobile Device Ethernet的网卡呢？
如果你的电脑没有联网，可以用这种方式，实现手机流量共享到电脑上网，这个时候电脑和手机之间建立了一个内部局域网，这个时候你打开手机上的MFiles，网页传文件可以发现，和连接WIFI一样的效果，但是这次是建立在USB之上的网络连接。
再试一下文件传输，速度可以达到12MB/s，虽然比起原生的20MB/s还有点差距，但是比WIFI速度快了近10倍，传一些电视剧也够用了。
但是电脑上要识别到Apple Mobile Device Ethernet这个网卡，还是要靠iTunes提供的USB驱动才行。
所以我尝试把iTunes的USB驱动给提取出来，我就是不想安装完整的iTunes，最后发现原来仅仅8个文件就足够了！
完全不需要安装完整的iTunes，不给系统增加任何负担，不会在任务管理器看到任何多余的进程。
nice!!!
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
提取USB驱动的方法：
1.解开iTunes安装包得到4个msi文件
2.解开AppleMobileDeviceSupport.msi
3.找到以下8个文件：usbaapl.inf，usbaapl.sys，usbaapl.inf.cat，usbaaplrc.dll，netaapl.inf，netaapl.sys，netaapl.cat，WdfCoInstaller01009.dll
4.插入苹果USB数据线，打开电脑的设备管理器，在便携设备下面找到Apple设备，右键更新驱动程序，路径选择usbaapl.inf所在的目录即可。
最后提供我提取的USB驱动32位系统适用：
https://download.csdn.net/download/qq446252221/11153774


C语言实现的简易FTP客户端
Fri, 19 Apr 2019 10:03:10 +0000
为了从FTP服务器下载文件，需要要实现一个简单的FTP客户端。
FTP（文件传输协议） 是 TCP/IP 协议组中的应用层协议。
FTP协议使用字符串格式命令字，每条命令都是一行字符串，以“\r\n”结尾。
客户端发送格式是：命令+空格+参数+"\r\n"的格式
服务器返回格式是以：状态码+空格+提示字符串+"\r\n"的格式，代码只要解析状态码就可以了。
读写文件需要登陆服务器，特殊用户名：anonymous，表示匿名。注意大小写敏感。
从FTP服务器下载文件的基本流程如下：


建立TCP连接，该协议默认使用21端口，当然可以指定其它端口，取决于服务器的配置。


连接成功之后，服务器会发送一行欢迎文字，例如：220 welcome.
其中左边的数字220表示就绪状态，220后面有一个空格，空格后面是提示文字。
在解析命令应答的时候，只需要获取前面的数字即可。


收到欢迎信息后，就要开始登陆了，先用USER命令发送用户名，服务器返回331状态。
然后再用PASS命令发送登陆密码，服务器返回530表示密码错误，返回230表示密码正确。
发送：USER anonymous
接收：331 Anonymous login ok, send your complete email address as your password
发送：PASS anonymous
接收：230 Anonymous access granted, restrictions apply


登陆成功之后，再发送一条TYPE I命令，进入二进制模式，这样获取文件数据的时候，就会以二进制字节流发送。
避免以ASCII码格式发送文件数据。


获取文件长度
发送：SIZE /path/filename
失败：550 /path/filename: No such file or directory
成功：213 [filesize]
返回[filesize]是十进制数字，表示该文件在大小，字节为单位


下载文件
下载文件前，先发送PASV命令，进入被动模式，这样FTP服务器就会开放一个新的端口，用于接收文件数据。
客户端成功连接到这个数据端口后，再发送RETR命令请求下载文件，这时文件数据就会从新的端口发送过来，文件传输完毕，服务器自动关闭数据端口。
发送：PASV
接收：227 Entering Passive Mode (145,24,145,107,207,235).
后面括号内的5个数字，分别表示IP地址和端口号，端口号分为高8位和低8位，高8位在前
这里的例子表示IP地址为145.24.145.107，端口号为53227(计算公式：207 * 256 + 235)。


Windows 7精简版(2019.04.10)
Wed, 10 Apr 2019 14:15:48 +0000
前一次制作的精简版Windows7运行了2个月，基本功能正常，可以稳定使用，并没有发现会影响使用的错误。
只有两个小问题，在此重新发布一个安装文件。
1.添加了verdana字体；Visual Assist的安装程序使用了此字体。
2.添加snmp组件；缺少此组件无法运行arp命令。
3.删除\Windows\System32\zh-cn\Licenses文件夹，节省7MB空间。
4.替换\Program Files\Windows Mail\msoe.dll为Vista版本，可以正常使用Win7自带的邮件系统。
下载地址： https://pan.baidu.com/s/1fqAgg5ClT6riEhjPmGpjAQ
提取码：8k6y
安装方法：
安装镜像使用Wim压缩方式打包，安装的时候，把C盘格式化，然后用GImageX解开此文件到C盘，重启电脑即可。


[初学python]表格文件读写操作
Tue, 09 Apr 2019 17:32:57 +0000
原生python并没有自带excel操作的类库，需要安装第三方类库xlrd和xlwt
安装方法：
pip install xlrd
pip install xlwt
一个Excel文件叫作一个Workbook，一个Workbook包含若干个工作表(sheet)，
一个工作表包含若干行和列，对其中的单元格(cell)可以进行读写操作。
以下是测试程序：
#测试读写excel文件
#需要安装xlrd和xlwt

import xlrd
import xlwt

def excel_read():
    w = xlrd.open_workbook("demo.xls")  #打开文件
    sheet = w.sheet_by_index(0)  #获取第1个工作表
    print("这是第1行，第A列的内容：", sheet.cell_value(0, 0))
    print("这是第1行，第B列的内容：", sheet.cell_value(0, 1))
    print("这是第2行，第A列的内容：", sheet.cell_value(1, 0))
    print("这是第2行，第B列的内容：", sheet.cell_value(1, 1))
    pass
    
def excel_write():
    f = xlwt.Workbook() #创建工作簿 
    sheet = f.add_sheet("sheet1") #创建sheet
    sheet.write(0, 0, "第1行，第A列")
    sheet.write(0, 1, "第1行，第B列")
    sheet.write(1, 0, "第2行，第A列")
    sheet.write(1, 1, "第2行，第B列")
    f.save("demo.xls")  #保存到文件
    pass
    
    
#程序入口
print("演示表格文件的读写...")
excel_write()
excel_read()
print("操作完毕.")



[初学python]文本文件读写操作
Tue, 09 Apr 2019 17:23:13 +0000
利用python脚本实现这样一个功能：
现有a.txt和b.txt两个纯文本文件，需要把a.txt和b.txt中相同的内容提取出来，保存为c.txt
#从A.TXT和B.TXT读取文本,提取相同的行存为C.TXT.
import io
import os

#判断是否包含这行
def is_line_in_lines(line, lines):
    line = line.rstrip("\r\n")
    for temp in lines:
        temp = temp.rstrip("\r\n")
        if temp == line:
            return True
    return False
    

#程序入口
f_a = open("a.txt", "r")
f_b = open("b.txt", "r")
f_c = open("c.txt", "w")
print("正在处理...")
lines1 = f_a.readlines()
lines2 = f_b.readlines()
for line in lines1:
    if is_line_in_lines(line, lines2):
            f_c.write(line)
f_a.close()
f_b.close()
f_c.close()
print("处理完成!")



[初学python]利用Win32API实现鼠标自动点击
Fri, 29 Mar 2019 18:08:31 +0000
python在Windows系统下可以调用win32 api来实现一些系统级的功能，比如控制鼠标和键盘来实现游戏辅助。
但是python并没有自带这些库文件，需要自己动手安装pywin32这个库，安装方法：pip install pywin32
今天就以Flash小游戏彩色砖块为实验对象，用python写一个自动点击的“游戏外挂”。
彩色砖块这个小游戏在 很多年前 出现在QQ空间3366小游戏。
一共200个方块，在规定时间内，点击空白区域，消除相同颜色的方块越多得分越高，满分200分。
那时候为了和QQ好友比赛，比分数高，就用C++写了一个辅助小程序，完成了200分。
今天为了学习python，再次找到它，把Flash文件下载到本地电脑，用独立的Flash播放器打开这个block.swf文件。
swf文件可以在我的网盘下载： http://446252221.ys168.com/ (文件路径：FLASH/block.swf)

代码思路和用C语言一样：
1.利用GetPixel函数，获取所有方块的颜色，保存到列表，
2.然后遍历所有的空白点，判断这个空白点的上下左右4个方向有没有相同颜色的方块，
3.如果有则调用SetCursorPos和mouse_event模拟鼠标点击，
4.重复第2，3步，直到所有空白区域都判断完毕。
注意事项：
需要事先分析方块的颜色值，游戏区域的坐标，以及方块的大小。
下面开始写代码：
#FLASH小游戏彩色砖块辅助工具
#以下参数需要调整
#窗口大小: 668 * 526
#游戏区大小: 660 * 499
#第一次点击开始:(330, 425)
#第二次点击开始:(320, 280)
#左上角第一个方块相对坐标: (60, 100)
#格子大小: 25 * 25
#格子数量: 23 * 15
#空白格子颜色: 0xF7F7F7 和 0xEDEDED
#实体格子颜色: 
#0x0066cc
#0x00cc00
#0x6666ff
#0xbbbbbb
#0xcccc66
#0x66cccc
#0xcc66cc
#0xff6600
#0xff88ff
#0x0099ff

import time
import win32gui
import win32ui
import win32api
import win32con

#查找游戏窗口，返回窗口起始坐标
def find_flash_window():
    hwnd = win32gui.FindWindow("ShockwaveFlash", "Adobe Flash Player 28")
    if(hwnd):
        rect = win32gui.GetWindowRect(hwnd)
        return rect[0],rect[1]
    return None

#模拟鼠标点击
def mouse_click(x, y):
    win32api.SetCursorPos([x, y])
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)
    
#点击格子
def click_block(xbase, ybase, x, y):
    x = xbase + x * 25 + 60
    y = ybase + y * 25 + 100
    mouse_click(x, y)


#颜色转换为方块类型
def convert_color_to_type(color):
    if(color == 0x0066cc):
        return 0x01
    if(color == 0x00cc00):
        return 0x02
    if(color == 0x6666ff):
        return 0x03
    if(color == 0xbbbbbb):
        return 0x04
    if(color == 0xcccc66):
        return 0x05
    if(color == 0x66cccc):
        return 0x06
    if(color == 0xcc66cc):
        return 0x07
    if(color == 0xff6600):
        return 0x08
    if(color == 0xff88ff):
        return 0x09
    if(color == 0x0099ff):
        return 0x0A
    if(color == 0xededed):
        return 0x00
    if(color == 0xf7f7f7):
        return 0x00
    return 0xFF
    
    
#获取方块类型
def load_one_block(hdc, xbase, ybase, x, y):
    x = x * 25 + xbase + 60;
    y = y * 25 + ybase + 100;
    color = win32gui.GetPixel(hdc, x, y)
    return convert_color_to_type(color)
    
#获取所有方块 
def load_all_block(map, xbase, ybase):
    hdc = win32gui.GetWindowDC(0)
    map.clear()
    for y in range(0, 14):
        list = []
        for x in range(0, 22):
            type = load_one_block(hdc, xbase, ybase, x, y)
            list.append(type)
        map.append(list)
    win32gui.ReleaseDC(hdc, 0)
    
#返回指定格子左边的方块
def find_left_block(map, x, y):
    for i in range(0, x):
        if(map[y][x - i] != 0x00):
            return map[y][x - i]
    return 0xFF
    
#返回指定格子右边的方块
def find_right_block(map, x, y):
    for i in range(x, 22):
        if(map[y][i] != 0x00):
            return map[y][i]
    return 0xFF

#返回指定格子上边的方块
def find_top_block(map, x, y):
    for i in range(0, y):
        if(map[y - i][x] != 0x00):
            return map[y - i][x]
    return 0xFF
    
#返回指定格子下边的方块
def find_bottom_block(map, x, y):
    for i in range(y, 14):
        if(map[i][x] != 0x00):
            return map[i][x]
    return 0xFF
    
#判断这个格子是否可以点击
def is_block_clickable(map, x, y):
    if(map[y][x] != 0) or (map[y][x] != 0):
        return False
    left = find_left_block(map, x, y)
    right = find_right_block(map, x, y)
    top = find_top_block(map, x, y)
    bottom = find_bottom_block(map, x, y)
    
    if(top == bottom) and (top != 0xFF):
        print("t = b:", top, bottom)
        return True
    if(top == left) and (top != 0xFF):
        print("t = l:", top, left)
        return True
    if(top == right) and (top != 0xFF):
        print("t = r:", top, right)
        return True
    if(left == right) and (left != 0xFF):
        print("l = r:", left, right)
        return True
    if(left == bottom) and (left != 0xFF):
        print("l = b:", left, bottom)
        return True
    if(right == bottom) and (right != 0xFF):
        print("r = b:", right, bottom)
        return True
    return False
    
#查找可以点击的格子
def find_click_block(map):
    for x in range(0, 22):
        for y in range(0, 14):
            if(is_block_clickable(map, x, y)):
                return x,y
    return None

def dump_all_block(map):
    for y in range(0, 14):
        for x in range(0, 22):
            print("%02X " % (map[y][x]), end="")
        print()
        
#程序入口
map = []
xbase = 0
ybase = 0
print("正在查找游戏窗口...")
pos = find_flash_window()
if(pos == None):
    print("查找游戏窗口失败!")
    exit()
print("查找游戏窗口成功.")
xbase = pos[0]
ybase = pos[1]
while(True):
    load_all_block(map, xbase, ybase)
    dump_all_block(map)
    print("正在查找可以点击的格子")
    pos = find_click_block(map)
    if(pos == None):
        print("游戏结束!")
        exit()
    print(pos)
    click_block(xbase, ybase, pos[0], pos[1])
    time.sleep(1)



[初学python]苹果何时开放IOS降级通道啊？
Tue, 26 Mar 2019 17:07:31 +0000
手机升级从iOS10升级到iOS12后，有点不适应，想降级到iOS10就没门了，太可恶了。
想着苹果曾经意外地开放过旧系统的验证通道，于是幻想会不会再次出现？
于是经常打开http://ipsw.me查询当前签名的系统版本，唉，频繁手动操作有点费时，
不如用python写个自动化脚本来实现吧，检测到IOS10的时候就给我发个邮件吧。
于是研究了一下ipsw.me，该网站提供查询接口了，并以json的格式返回数据。
于是就有了下面的代码：
定时访问ipsw.me提供的接口，检测到IOS10系统有效就发送邮件给我。
发送邮件使用了网易提供的邮件接口。
间隔10分钟查询一次，就让它在电脑的后台24小时运行吧，万一哪天真的它就给我发邮件了呢。嘿嘿。。。
#发现IOS10可以降级时通过邮件通知我
#QQ:446252221
#2018.05.10
import io
import time
import json
import urllib.request
import smtplib
import email.mime.text
import email.mime.multipart 

#获取当前时间
def local_time_str():
    str = time.strftime("%Y-%m-%d %X", time.localtime(time.time()+28800))
    return str

#通过网易的SMTP服务器发送邮件
def send_mail(title, content):
    mail_host = "smtp.163.com"           #设置服务器
    mail_port = 25                       #SMTP端口号
    mail_user = "############@163.com"   #用户名
    mail_pass = "########"               #口令(授权码)
    mail_recv = ["446252221@qq.com"]     #收件人
    mail_subject = title                 #邮件主题
    mail_content = content               #邮件正文

    msg = email.mime.multipart.MIMEMultipart()  
    msg["From"] = mail_user
    msg["To"] = mail_recv[0]
    msg["Subject"] = mail_subject
    msg.attach(email.mime.text.MIMEText(mail_content))

    try:
        print("正在发送邮件...")
        smtp_obj = smtplib.SMTP()
        smtp_obj.connect(mail_host, mail_port)    
        smtp_obj.login(mail_user, mail_pass)
        smtp_obj.sendmail(mail_user, mail_recv, msg.as_string())
    except:
        print("邮件发送失败!")
        return False
    else:
        print("邮件发送成功.")
        return True

#调用ipsw接口,查询可升级的IOS版本
def call_ipsw(iphone):
    try:
        print("正在获取数据...");
        request_url = "https://api.ipsw.me/v4/device/" + iphone
        session = urllib.request.urlopen(request_url)
    except:
        print("获取数据失败!")
        return None
    else:
        print("获取数据成功.")
        respon_body = session.read()
        json_obj = json.loads(respon_body.decode("utf-8"))
        ios_all_list = json_obj["firmwares"]
        ios_signed_list = []
        for item in ios_all_list:
            if item["signed"]:
                ios_signed_list.append(item["version"])
        return ios_signed_list

#程序入口
while True:
    print("当前系统时间：", local_time_str())
    ios_list = call_ipsw("iPhone8,4")
    for ios in ios_list:
        print("当前IOS版本：", ios)
        if ios.startswith("10."):
            send_mail("苹果开放IOS10降级通道啦！", "当前可降级版本为："+ios)

    #延时10分钟
    time.sleep(600)



[初学Python]利用某网站的功能写一个磁力链转种子工具
Mon, 25 Mar 2019 18:00:03 +0000
孔子曰：学而时习之~
初学python，一边看语法，一边看参考例程，写了一个小程序，做个存档，否则很容易忘记。
这次的目标是利用某种子下载网站，编写一个磁力链下载种子文件的工具。
常见的种子文件磁力链接的格式是这样的： magnet :?xt=urn:btih:XXX
其中的XXX就是种子文件的哈希值，而这个网站可以输入哈希值，下载对应的种子文件，
但是该网站广告内容太多了，用浏览器打开不太方便呀~，具体是哪个网站我就不说了，哈哈~~~，自己看代码吧。
# 磁力链接转种子文件
# QQ:446252221 <446252221@qq.com>
import io
import os
import time
import urllib.request
import urllib.parse
import html.parser

USER_AGENT = "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"

#HTML解析
class html_dumper(html.parser.HTMLParser):
    
    def __init__(self):
        html.parser.HTMLParser.__init__(self)
        self.key = ""
        
    def handle_starttag(self, tag, attrs):
        if tag == "input":
            if attrs[1][1] == "key":
                self.key = attrs[2][1]
        return None
        
    def handle_data(self, data):
        return None
            
    def handle_comment(self, data):
        return None
        
    def get_key(self):
        return self.key
        
#第1步获取key
def step1_get_key(hash):
    req_url = "http://www.storetorrents.com/hash/" + hash
    req = urllib.request.Request(url=req_url, method="GET")
    req.add_header("User-Agent", USER_AGENT)
    try:
        respon = urllib.request.urlopen(req)
        #print("第1步:", respon.status)
        respon_cook = respon.getheader("Set-Cookie")
        respon_body = respon.read()
        dumper = html_dumper()
        dumper.feed(respon_body.decode("utf-8"))
        #print("key:", dumper.get_key())
        return dumper.get_key()
    except BaseException as e:
        print("urlopen error:", e)
        return None
        
#第2步获取captcha
def step2_get_captcha():
    req_url = "https://storetorrents.xyz/captcha"
    req = urllib.request.Request(url=req_url, method="GET")
    req.add_header("User-Agent", USER_AGENT)
    #req.add_header("Cookie", "__cfduid=dac7712102a83c5d8e2d3fb4ec6f407031553505032; PHPSESSID=25d2d5kd6erdqbo1fv4o4e8vs2")
    try:
        respon = urllib.request.urlopen(req)
        #print("第2步:", respon.status)
        respon_body = respon.read()
        respon_cook = respon.getheader("Set-Cookie")
        file_name = "captcha.jpg"
        file_obj = open(file_name, "wb")
        file_obj.write(respon_body)
        file_obj.close()
        os.system(file_name)
        #print("cookie:", respon_cook)
        cookie_list = respon_cook.split(";", -1)
        cookie = cookie_list[0] + ";" + cookie_list[5].split(",", 1)[1]
        #print("cookie:", cookie)
        return cookie
    except BaseException as e:
        print("urlopen error:", e)
        return None
    
    
#第3步下载文件
def step3_download(key, hash, captcha, cookie):
    req_url = "https://storetorrents.xyz/download"
    req_values = {}
    req_values["key"] = key
    req_values["infohash"] = hash
    req_values["captcha"] = captcha
    req_body = urllib.parse.urlencode(req_values)
    #print("key encode:", req_body)
    req = urllib.request.Request(url=req_url, method="POST", data=bytes(req_body, encoding="utf8"))
    req.add_header("User-Agent", USER_AGENT)
    req.add_header("Cookie", cookie)
    try:
        respon = urllib.request.urlopen(req)
        #print("第3步:", respon.status)
        type = respon.getheader("Content-Type")
        #print("Type:", type)
        if type.startswith("text/html"):
            print(respon.read().decode("utf-8"))
            return None
        respon_body = respon.read()
        file_name = hash + ".torrent"
        file_obj = open(file_name, "wb")
        file_obj.write(respon_body)
        file_obj.close()
        print("下载完成!")
    except BaseException as e:
        print("urlopen error:", e)
    return None
    
#入口
os.system("title 磁力转换工具")
os.system("echo off")
while(True):
    hash = input("magnet:?xt=urn:btih:")
    key = step1_get_key(hash)
    if key == None:
        print("未找到该资源!")
        os.system("pause")
        continue
    cookie = step2_get_captcha()
    if cookie == None:
        print("获取验证码失败!")
        os.system("pause")
        continue
    code = input("请输入验证码:")
    step3_download(key, hash, code, cookie)
    os.system("pause")
    
简单解释一下代码内容：


UC1617点阵屏幕驱动
Thu, 21 Mar 2019 17:12:16 +0000
UC1617是一个单色点阵液晶屏驱动芯片，最大支持128*128分辨率。
芯片手册： https://download.csdn.net/download/qq446252221/11045952
首先要注意的是：这个驱动芯片与其它单色液晶驱动芯片有点不一样，因为它是支持4位灰度显示的！
所以它的一个像素点是2个比特，而不是普通单色屏幕那样一个像素1个比特。
1个字节8比特，对应屏幕上的4个像素点。
这个芯片支持IIC，SPI，8080通信接口，通信时序就不详细说了，看看手册就行了。
对于SPI接口：SCK上升沿时LCD采样数据，SCK下降沿LCD输出数据。
重点关注的是初始化命令，对寄存器的配置。
从手册得知，其命令编码规则是不定长编码，一个字节前面M个比特表示特定命令，剩于N比特表示数据。
M和N的长度每个命令基本都不一样。如下图所示：

验证硬件通信是否成功，应该先测试Get Status这个指令，连续读出3个字节，末尾两个字节可以判断通信是否正常。
正常情况应该是0x1E,0x00,0x74，其中第1个字节与配置有关，后面2个字节是固定值。
需要注意的时，SPI接口有特殊的命令来获取状态：

先要用SPI发送0xFE这个指令，再连续读3个字节，才是状态。
发送0xFE前CS0拉低，CD拉低表示指令，发送完0xFE后，把CD拉高表示数据，连续读3个字节，最后CS0拉高，通信结束。
伪代码如下：
void lcd_get_status(uint8_t state[3])
{
    lcd_send_cmd(0xfe);
    state[0] = lcd_recv_data();
    state[1] = lcd_recv_data();
    state[2] = lcd_recv_data();
}
手册上没有提到的SPI指令是读显存数据，与SPI读状态类似，读显存的命令字是0xFF。
以下是初始化命令伪代码：
void lcd_chip_setup(void)
{
    lcd_send_cmd(0xeb); //bias set 1/11
    lcd_send_cmd(0x24); //set tem compensation -0.15%
    lcd_send_cmd(0x2a); //set panel loading >40nF
    lcd_send_cmd(0x2F); //set pump PC[2];internal VLCD
    lcd_send_cmd(0x81); //set Vop PM[7:0]
    lcd_send_cmd(0x34); //PM[7:0]=0x34
    lcd_send_cmd(0x84); //set partial display
    lcd_send_cmd(0x8b); //set RAM address control AC[2:0]
    lcd_send_cmd(0xc0); //set LCD mapping control My Mx LC0,C2
    lcd_send_cmd(0xa3); //SET line rate  LC[4:3]
    lcd_send_cmd(0xad); //SET B/W MODE  AND DISPLAy ON  DC[ 3:2 ]
    
    //设置显示区域，默认值是就0 - 127,可以不用设置
    lcd_send_cmd(0xf4); //SET start x
    lcd_send_cmd(0x00); 
    lcd_send_cmd(0xf5); //SET start y
    lcd_send_cmd(0x00); 
    lcd_send_cmd(0xf6); //SET end x
    lcd_send_cmd(0x1f);
    lcd_send_cmd(0xf7); //SET end y
    lcd_send_cmd(0x7f);
}
写显存数据:


Windows 7精简版(2019)
Sat, 16 Feb 2019 13:54:56 +0000
此前的精简版使用NTLite免费版制作，受功能限制，有一些组件无法移除；
此次找到了NTLite企业版，没有功能限制，重制了一个精简版。
保留IE8，但可以安装IE9，IE10，IE11.
为了支持升级IE浏览器，以下组件不能删除，否则安装会失败：
1.Windows 帮助内容
2.多国语言支持：保留简体中文和英语
3.疑难解答
2019.04.10: 已有更新版本，此版本暂停分享。
下载链接： https://pan.baidu.com/s/1W8tO7vXuCgC_NuTahB2dDA
精简了以下组件：
由于内容过长，无法提交，因此打包上传到百度网盘
使用NTLite精简后，还可以手动删除一些文件：
由于内容过长，无法提交，因此打包上传到百度网盘
链接: https://pan.baidu.com/s/1Yb_IN0hkQOVa5PXQI4j8FQ 提取码: 99vs


nrf52832使用freeRTOS低功耗模式的笔记
Thu, 14 Feb 2019 10:59:43 +0000
一般而言，RTOS的运转需要一个滴答定时器周期性地产生中断来为系统提供时钟，通常是1毫秒或者10毫秒。
对于低功耗应用场景，定时器会频繁地产生中断，使得MCU频繁被唤醒，导致功耗升高，无法满足项目需求。
freeRTOS中引入了TICKLESS模式来实现低功耗应用。
TICKLESS模式的原理是动态地改变系统时钟的中断频率，当没有任务运行时，保持MCU处于睡眠模式，减少不必要的时钟中断。
nordic nrf52832的SDK中提供了freeRTOS的低功耗应用实例，阅读源码后做一些笔记：
在freeRTOS中全局变量[xNextTaskUnblockTime]记录着下一个任务唤醒的时间，[xTickCount]记录着当前系统时间，
当系统处于空闲任务时，使用[xNextTaskUnblockTime - xTickCount]计算出MCU可以睡眠的时长，
将计算结果传给portSUPPRESS_TICKS_AND_SLEEP函数，这个函数在port_cmsis_systick.c中实现，
该函数修改RTC的中断模式，然后使用WFE的方式让MCU进入睡眠模式，当MCU被事件唤醒之后，恢复RTC中断为之前的状态。
备注：WFE方式的唤醒方式可以是SEV指令，也可以是任意中断事件，使用中断唤醒需要提前设置SEVONPEND位。
SDK的代码中在port_cmsis.c使用了SCB->SCR |= SCB_SCR_SEVONPEND_Msk;


VS2005精简版(二)
Tue, 15 Jan 2019 15:43:12 +0000
上个版本精简版VS2005发现一个小问题，双击*.sln文件不能打开文件。
于是又研究了一番注册表，*.sln的文件关联比较特殊，它可以识别文件内容，显示不同的图标。
重新注册VSFileHandler.dll没有解决，但是发现注册的时候，它会自动生成很多注册表内容，
于是发现大量的注册表项都是由这些COM组件生成的，
这些COM组件相关的注册表主键主要在HKCR/CLSID、HKCR\TypeLib、HKCR\Interface、HKCR\Record。
这几项注册表的内容占了大半，这部分内容既然是注册DLL的时候生成的，那么可以在安装脚本中删除，
然后重新注册DLL，直接把安装脚本从3W多行，骤降至8000行。
顺便将这些DLL的路径从C：\Program Files\Common Files\Microsoft Shared移动到VS2005的安装目录，
减少安装过程的文件复制操作，但是.NET相关的文件还是要复制到系统目录的C:\Windows\assembly。
最后发现*.sln文件关联需要手动添加注册表，使用VSLauncher.exe启动。
顺便把setup文件夹下面的文件调整了一下，默认不安装vc80.debug，因为WinXP和Win7的winsxs结构有点不一样。
WIN7系统可以手动安装vc80.debug，只要运行setup/install_vc80_debug.bat即可。
重新打包inno setup，在XP和Win7系统下做测试，安装后使用正常。
最后用xz压缩为压缩包只有65MB。
上传度盘分享给有缘人： https://pan.baidu.com/s/1FmtekIEVHYy-OtEgU3-IPg


VS2005精简版
Fri, 11 Jan 2019 16:18:50 +0000
从毕业到现在,一直都在使用Visual Studio 2005来开发C/C++小程序,每次重装系统就要重装VS2005，
这家伙安装起来太慢了，如果要打SP1补丁那更费时间，所以有必要制作一个精简版！（都2019年了啊，早干嘛去了啊？？？）
我只需要安装VC++的组件就行了，重装系统的时候就可以分分钟搞定VS2005。
首先用虚拟机装了一个Win7 32位纯净系统,然后备份硬盘文件，然后在里面安装VS2005,对比两个硬盘镜像的差异，
从而提取出VS2005所需的文件，不过不看不知道，一看吓一跳！这个家伙竟然向注册表写了接近10W行数据！！！
握草！！！！！！！！
不怕把注册表写坏了吗！！！
除了注册表之外还有好几千个文件被写到了以下目录：
C:\Program Files\Visual Studio 8\
C:\Program Files\Common Files\
C:\Windows\Assembly\
C:\Windows\System32\
C:\Windows\WinSXS\
这样的目录结构，想要把Visual Studio做成绿色版是绝逼不可能的了，但是可以做成精简版，直接复制相关文件和注册表就可以完成安装，再怎么说也比DVD镜像里面的安装程序要快很多。
话虽如此，但是如此之多的注册表项和文件，要精简起来十分费时！
不过还好我不是世界上第一个制作VS2005精简版的人，网上能找到cntrup和skygz前辈制作的精简版。
不过这两位的精简版还是不太满意，安装过程有一些小问题，精简程度也还不够。
参考前辈的精简版成品和我提取的VS2005再进行整理，用inno setup打包成快速安装程序，
这个安装程序其实写注册表和注册必要的dll文件，不用复制文件到C盘，所以安装速度很快。
下面做点精简笔记，以纯净的WIN7 32位系统为基础：

将VS2005的程序目录放到D：\VS2005\，运行Common7\IDE\devenv.exe，提示应用程序配置不正确，程序无法运行？

这是因为VS2005是基于VS2005开发的，需要安装VC++ 2005运行时库才可以。

安装VC++2005后，再次运行devenv.exe，提示一个或多个组件没有找到？

这是因为还没有写入注册表，所以VS2005完全不能运行，需要把刚才提取的注册表项导入。

导入注册表项后，再次运行devenv.exe，提示文件加载失败，%commondir%\dte80.olb？

这是因为VS2005依赖的一部分DLL竟然要放到C:\Program Files\Common Files\

复制这些DLL到C:\Program Files\Common Files\之后，再运行devenv.exe，终于看到初始化界面了，但过了一会儿提示“无效的许可证数据”？

这个问题有点奇怪，明明把完整的注册表项都导入了，为什么注册没有成功，这次找到了前辈的安装程序，发现发vsreg.exe，用这个小工具重新注册一下就可以了。

重新注册VS2005之后，再运行devenv.exe，又提示一堆Package加载失败？

嗯，很烦，VS2005的很多Package是基于.NET平台开发的，所以还要重复这些文件到C:\Windows\Assembly目录啊！

复制.net组件后，再运行devenv.exe，终于成功了，但是编译helloworld无法运行，还是提示应用程序配置不正确？

这个嘛，是因为DEBUG版本程序依赖DEBUG版的VC++运行时库，需要拷贝几个dll和manifest文件到C:\Windows\Winsxs，还要把这几个DLL注册到注册表项。
7.处理好winsxs目录的文件，VS2005终于可以正常工作了。
好了，剩下的事情就是精简了，所谓精简就是不停地删除那些我一辈子都用不到的组件，然后还要删除对应的注册表项，
这就是个相当耗费精力的过程。。。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
不知道过了多久，删除了一堆又一堆DLL文件，删除了一行又一行的注册表项，而且要保证VS2005运行时不出错。
最后的文件结构：
\Common7\*        IDE核心文件
\Setup\*          安装时会引用的文件
\VC\bin           VC++编译器，可以替换为VS2010或者其它版本，可以实现对C++11的支持。
\VC\atlmfc        MFC库文件、头文件、源代码。可以替换为VS2010或者其它版本。
\VC\crt           CRT的源代码，没有太多作用，可以删除。
\VC\PlatformSDK   Windows的SDK头文件和库文件，VS2005提供的SDK是基于windows XP的，可以替换为其它版本
\VC\*             VC++工程核心文件
\setup.exe        快速安装程序
做好了成品放到百度网盘，分享给有缘人吧：


winsxs探索之组件的本质:文件与注册表
Tue, 01 Jan 2019 11:15:10 +0000
是谁在解析应用程序的manifest文件？它又是怎么去查找相关的组件的？
我觉得要搞清楚这个问题，才能彻底解决winsxs带来的问题。
仅仅依靠sxstrace给的那点提示是不够的，还需要了深入地了解发生在它背后的事情。
在Windows系统组件的本质其实就是文件和注册表。
所以通过监控应用程序启动过程中整个系统对注册表和文件系统的访问动作来寻找答案。
很快便发现了一个叫做csrss.exe的进程，访问了winsxs相关的目录和注册表。
并且这些访问与启动的应用程序manifest里描述的组件信息完全吻合。
这里以Debug版的demo程序为例，
csrss进程先后读取了以下内容：
注册表：
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\SideBySide\Winners\x86_policy.9.0.microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_none_3f3c83b270d599c8]
文件：
C:\Windows\winsxs\manifests\x86_policy.9.0.microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_3c8576a8f974f0b8.cat
注册表：
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\SideBySide\Winners\x86_microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_none_eaaf859ba152a8ae]
文件夾：
C:\Windows\winsxs\x86_microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_96748342450f6aa2\
有了这个信息，再来解决"应用程序配置不正确程序无法启动”的问题就变得清晰明了了。
当出现"应用程序配置不正确程序无法启动”的时候，我们只要监控csrss.exe进程访问了哪些注册表项和系统文件，
就可以顺藤摸瓜找到winsxs组件的安装方法了。
这样即使微软不提供Microsoft.VC++.Runtime的安装包程序，我们也可以手动找到这些dll文件，复制到winsxs对应的目录，然后写入正确的注册表项就完手动完成了。
这里贴上一个VC90.debugcrt的在winsxs目录的树形结构以作参考：
winsxs
├── manifests
│   ├── x86_microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_96748342450f6aa2.cat
│   ├── x86_microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_96748342450f6aa2.manifest
│   ├── x86_microsoft.vc90.debugmfc_1fc8b3b9a1e18e3b_9.0.21022.8_none_9b54853441e399d5.cat
│   ├── x86_microsoft.vc90.debugmfc_1fc8b3b9a1e18e3b_9.0.21022.8_none_9b54853441e399d5.manifest
│   ├── x86_microsoft.vc90.debugopenmp_1fc8b3b9a1e18e3b_9.0.21022.8_none_469e7800ca24708e.cat
│   ├── x86_microsoft.vc90.debugopenmp_1fc8b3b9a1e18e3b_9.0.21022.8_none_469e7800ca24708e.manifest
│   ├── x86_policy.9.0.microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_3c8576a8f974f0b8.cat
│   ├── x86_policy.9.0.microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_3c8576a8f974f0b8.manifest
│   ├── x86_policy.9.0.microsoft.vc90.debugmfc_1fc8b3b9a1e18e3b_9.0.21022.8_none_37ea0b5cfc57dfad.cat
│   ├── x86_policy.9.0.microsoft.vc90.debugmfc_1fc8b3b9a1e18e3b_9.0.21022.8_none_37ea0b5cfc57dfad.manifest
│   ├── x86_policy.9.0.microsoft.vc90.debugopenmp_1fc8b3b9a1e18e3b_9.0.21022.8_none_8b162516588f5ada.cat
│   └── x86_policy.9.0.microsoft.vc90.debugopenmp_1fc8b3b9a1e18e3b_9.0.21022.8_none_8b162516588f5ada.manifest
├── x86_microsoft.vc90.debugcrt_1fc8b3b9a1e18e3b_9.0.21022.8_none_96748342450f6aa2
│   ├── msvcm90d.dll
│   ├── msvcp90d.dll
│   └── msvcr90d.dll
├── x86_microsoft.vc90.debugmfc_1fc8b3b9a1e18e3b_9.0.21022.8_none_9b54853441e399d5
│   ├── mfc90d.dll
│   ├── mfc90ud.dll
│   ├── mfcm90d.dll
│   └── mfcm90ud.dll
└── x86_microsoft.vc90.debugopenmp_1fc8b3b9a1e18e3b_9.0.21022.8_none_469e7800ca24708e
    └── vcomp90d.dll
除了文件以外，还有几项必须的注册表：


winsxs探索之sxstrace错误跟踪工具
Mon, 31 Dec 2018 21:24:02 +0000
当程序弹出"应用程序配置不正确程序无法启动”的时候，都会提示你使用sxstrace工具来追踪信息。
sxstrace工具的用法是这样的：
第一步：输入并运行SxsTrace Trace -logfile:log.etl
第二步：运行你的测试的程序hellp.exe
第三步：在刚才的命令窗口按下回车，停止日志收集
第四步：输入并运行SxsTrace Parse -logfile:log.etl -outfile:log.txt
第五步：打开log.txt
找开log.txt文件后，给到的信息并不多，只能看出是这个程序的哪个组件没有找到。


winsxs探索之应用程序配置不正确程序无法启动
Mon, 31 Dec 2018 21:00:11 +0000
“应用程序配置不正确程序无法启动”这是经常会遇到的错误提示。那么它到底意味着什么，如何解决这个问题？

这个错误提示意味着什么？

意味着此程序运行所需的组件不存在。
这个组件的描述在程序的manifest文件里。
大多数manifest文件是以资源的形式内嵌在可执行文件里面的。
这个文件长什么样？我随便找来了一个EXE文件来研究，导出它的资源文件:/.rsrc/1033/manifest/1
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
    <dependency>
        <dependentAssembly>
            <assemblyIdentity type="win32" name="Microsoft.VC80.CRT" version="8.0.50608.0" processorArchitecture="x86" publicKeyToken="1fc8b3b9a1e18e3b">
            </assemblyIdentity>
        </dependentAssembly>
    </dependency>
    <dependency>
        <dependentAssembly>
            <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" processorArchitecture="x86" publicKeyToken="6595b64144ccf1df" language="*">
            </assemblyIdentity>
        </dependentAssembly>
    </dependency>
</assembly>
从这个文件内容可以看出，它的本质是一个类似XML的文本文件，dependency节点描述了此程序运行所需的组件信息，这个文件里面有两个dependency节点，分别描述了两个组件，一个是Microsoft.VC80.CRT，另一个是Microsoft.Windows.Common-Controls。
Microsoft.VC80.CRT 就是VS2005编译器所带的VC++运行时库版本，说明此程序是用VS2005开发的。
Microsoft.Windows.Common-Controls 就是Windows的通用控件库，这个一般是系统都有的组件，可能版本有所不同。
这里我们以Microsoft.VC80.CRT为例，
从文件内容可以看出，这个组件的其它信息：
CPU架构是X86，
系统类型是Win32，
版本号是8.0.50608.0，
公钥令牌是：1fc8b3b9a1e18e3b

如何解决这个问题？

如果这个程序运行时提示：应用程序配置不正确程序无法启动
那么很可能是系统中没有Microsoft.VC80.CRT这个组件，或者组件版本不正确，只要安装正确的版本就能解决。


为精简版VS2008添加DEBUG版运行时库到系统目录
Mon, 31 Dec 2018 20:29:05 +0000
首先要感谢精简版VS2008的作者：风铃夜思雨（ https://bbs.pediy.com/thread-66741.htm ）
很可惜这个资源在2018年的今天过于老旧，网上已经快要绝版了。
原作者的V1.03版本VS2008SP1在网上已经找不到资源了，现在我能找到的只有原作者的V1.01版本。
完整的VS2008实再太臃肿，安装过程也需要很多时间，而且还附带了一大堆C++开发跟本用不上的组件，
诸如什么Web Designer，Document Explorer, SQL Server Express等等等。。。。。。
精简版只包含C++开发所需的编译器，SDK库文件，和IDE组件，体积小，便于安装，启动速度也更快。
但对于99.9%的人来说都不会使用这类精简版的工具，因为大多数人都害怕出现问题，又没有能力解决问题。
对于搞技术的人就是要有能折腾的精神，遇到问题解决它便是！
再次致敬作者！
众所周知，Visual Studio编译的目标程序分DEBUG版和RELEASE版。
如果使用动态链接发布程序，那么运行的时候需要安装对应版本的VC++运行时库（以下简称CRT）。
Release版的CRT很容易在网上找到资源，但是DEBUG版的确没有任何资源，
因为一般来说微软是不允许开发者发布DEBUG版的程序的，而DEBUG版CRT是伴随VS一起安装到本地系统的。
正好这个精简版VS2008是没有把DEBUG版CRT安装到系统目录，在调试程序的时候会弹出程序无法运行的错误，
别人的解决方法是把编译选项改为静态链接，或者把DEBUG版的msvcr80d.dll文件复制到程序目录。
这些方法虽然可以临时解决问题，但是不够方便，最好的办法是把DEBUG版CRT安装到系统目录。
在Windows系统上所谓的安装软件，无非就是两个过程：复制文件和写入注册表。
如果监控VS2008在安装的过程中的所有复制文件操作和注册表操作，这会非常困难，因为VS2008在安装过程中复制的文件数目多到令人发指，工作量很大。
所以我们倒着来寻找线索，利用程序运行时报错的信息来反向找到正确的DLL文件路径和相关的注册表项。
中间的过程比较坎坷，不过让我对winsxs的了解更加熟悉了，关于winsxs的内容放到另一篇文章吧，
这里就不多说了，直接放上我的研究结果吧。
下载这个压缩包，复制文件和添加注册表项即可。
x86_microsoft.vc90.debug下载地址：
https://download.csdn.net/download/qq446252221/10887422
x86_microsoft.vc80.debug下载地址：
https://download.csdn.net/download/qq446252221/10890793


socket编程为什么不会弹出Windows防火墙安全警告？
Fri, 21 Dec 2018 15:43:33 +0000
在启动了Windows防火墙的电脑上，第一次运行QQ，Chrome等网络程序的时候，会弹出一个安全警告，如图：

但是为什么自己用socket编程接口，开发的网络小程序，不会弹出这个窗口来呢？
经过一番研究，发现了原因：
在socket编程的流程中，有一个bind函数，用于绑定本机IP地址和端口号。
而这个bind函数就是防火墙弹窗的关键。
{	
int ret;
sockaddr_in addr;
SOCKET s;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.S_un.S_addr = inet_addr("0.0.0.0");
s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
ret = bind(s, (struct sockaddr *)&addr, sizeof(addr));
}
如上代码片段，调用bind函数，绑定本机IP地址和端口号。
如果addr.sin_port = 0，表示由系统分配一个端口号，这种情况下，Windows防火墙不会提示。
如果addr.sin_port = 非0值，表示程序指定一个端口号，这种情况下，Windows防火墙就是弹出提示。


32位Windows 7开启PAE可以识别4GB以上内存
Sun, 21 Oct 2018 17:12:48 +0000
众所周知32位Windows 7系统最大只能识别4GB内存，并且可用内存最多为3.25GB.
但是32位的Windows Server 2003/2008却可以使用4GB以上内存，原因就在于这个系统可以利用x86的PAE特性。
然而默认情况Windows 7却无法使用PAE特性，原因在于系统内核层屏蔽了此功能，
网传的修改BCD参数，bcdedit /set pae forceenable 设置PAE模式为:ForceEnable，实测并没有作用。
不过早就有大神开发32位系统内核的PAE补丁(PatchPae2.exe)！
大概在2012年左右就发布了支持Windows7/8版本的PAE内核补丁，而我在6年后的今天才知道，相当的后知后觉！
在我的这台破旧的4GB笔记本上面实测有用，写下记录过程，以便以后查阅：
一、补丁下载地址： https://pan.baidu.com/s/1BT3g_AMx9v2FakR0G6KizA
二、补丁使用方法：
1.将PatchPae2.exe复制到C:\Windows\System32\目录
2.以管理员身份运行cmd.exe
3.依次输入以下命令，将会在C:\Windows\System32\目录下生成两个系统文件.
PatchPae2 -type kernel -o ntkrnlpa_pae.exe ntkrnlpa.exe
PatchPae2 -type loader -o winload_pae.exe winload.exe
4.使用BOOTICE.exe工具编辑BCD文件，（因为使用bcdedit输入命令太麻烦了，所以用这个GUI工具）
为了避免启动失败，最好新建一个启动项，使用高级编辑模式，修改下图红框中的3个参数即可。 
重新启动电脑，选项新建的PAE启动项测试，结果如下：
任务管理器显示总的物理内存为4020MB

系统属性显示安装内存4.00GB，以前的“可用2.99GB”的字样消失了。



nRF51822关于GPIOTE模块的外部中断问题
Tue, 25 Sep 2018 14:12:55 +0000
nRF51822的GPIO的外部中断单独做成了一个模块，叫做GPIOTE，除了产生外部中断事件外，还支持输出任务。
这里重点关注一下外部中断的功能，GPIOTE有两种外部中断模式：
一种是IN_EVENT
这种模式可以独立配置4个通道，每个通道都有专门的中断标志位，可以任意指管脚和中断触发方式：上升/下降/翻转
当检测到对应的电平跳变后，将产生中断，触发GPIOTE_IRQHandler函数，但是这种模式有一个严重的问题，那就是静态功耗有1.3mA，对于低功耗芯片来说，这个功能就相当的鸡勒了。
另一种是PORT_EVENT
这种模式所有GPIO外部中断共用一个中断标志，在GPIOTE模块中，没有多余的参数配置寄存器。
要用它实现外部中断，需要在GPIO模块中配置对应的管脚打开SENSE功能，而GPIO的这个SENSE功能呢，
它的功能是检测GPIO电平，如果满足PIN_CNF[17:16]设置的条件，则将DETECT信号拉高。
这个DETECT信号是内部信号，每个PIN都有一条独立的DETECT信号，而所有的DETECT信号又由系统以[逻辑或]的方式合并为一条通用的DETECT信号，当这条通用的DETECT信号产生上升沿跳变的时候，就会产生一次PORT_EVENT中断。
PORT_EVENT中断方式功耗极低，但是却存在多个GPIO冲突的情况，导至中断不能正确地触发。


修复Keil5的菜单栏字体
Tue, 28 Aug 2018 15:21:59 +0000
用Keil5已经相当长的时间了，一直觉得Keil5的菜单栏字体看着不顺眼，应该只有处女座才会注意到吧？
特别是把Windows 7主题设置为经典主题之后,系统字体已经变为宋体，
搞开发的电脑屏幕分辨率又不高，且DPI为96的硬件条件下，用宋体做系统字体比较清晰。
因为宋体在字号为9-13这个范围时，使用的是点阵字体，所以效果非常锐利不会出现模糊。
然而Keil的菜单栏字体却很模糊，整个菜单栏如下图的模糊效果：

这个"Close"单词变形很严重，太难看了，由此可以推测它跟随了系统菜单的字形，但没有使用系统菜单的字号！
于是今天对UV4.exe做了一番研究，发现它获取到系统菜单的字体之后，又对字体大小做了一堆操作！
得出一个新的字体大小，并使用这个新的字体,创建了这个菜单栏！
所以最后我修改UV4.exe还原了菜单栏的字体大小,这样就与系统菜单保持一致了，如下图：

这个处女座纠结的问题总算被解决了^_^
终于可以把注意力放到写代码上面，而不用纠结这个菜单栏了。
哈哈哈哈………..
附上修改后的UV4.exe: https://download.csdn.net/download/qq446252221/10631414
我所用的Keil版本号是V5.18


Windows中的字体映射关系
Mon, 30 Jul 2018 10:27:48 +0000
从软件开发的角度，研究如何自定义Windows的系统字体。
在Windows程序开发中经常使用CreateFont创建指定的字体，其中一个参数"lpszFace"指定了字体名称。
那么系统是如何加载这个字体的？
首先会从注册表中查找:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts
这里列出了系统中已经安装的字体信息，以及该字体对应的字体文件名(默认路径是C:\windows\fonts)。
如果找到了，则加载对应的字体到内存，用作文字输出。
如果没找到呢？
系统还会寻找:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontSubstitutes
这里定义的是复用字体，如果系统中没有安装指定的字体，但是可以在这里添加一个表项，指向系统中已有的字体。
如果还是没有找到呢？
那么CreateFont函数可能会返回失败，文字输出可能会使用一个叫做“System, 16”的字体代替。
在研究注册表的时候，还有一个表项：
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontLink\SystemLink
这里定义的是字体链表，作用是当我加载的字体中没有要显示的文字的时候，就会从这里找到对应字体的备选字体文件。
从备选字体中加载要显示的文字。

所以如果要安全地去掉“微软雅黑”字体的方法就是：


在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts中删除微软雅黑


在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontSubstitutes中设置微软雅黑的别名


3.重启电脑
4.删除C:\Windows\Fonts\msyh.ttf


关于mingw里面swprintf函数的问题
Sat, 28 Jul 2018 12:53:09 +0000
mingw中的swprintf函数声明与iso c语言标准的有些差异，这个函数定义在wchar.h中。
iso c99标准定义如下：
int swprintf (wchar_t* ws, size_t len, const wchar_t* format, ...);
而在mingw当中是这样的：
int swprintf (wchar_t*, const wchar_t*, ...);
少了一个size_t的参数，这是什么原因造成的呢？
mingw当中定义的swprintf是由windows提供的msvcrt.dll实现的，
而msvcrt.dll在windows 95中就存在了。
1995年iso c99标准还没有问世，而iso c89标准又没有定义wchar.h。
所以大概就是windows 95编写的时候，还没有swprintf函数，所以呢这是一个windows系统自定义的非标准函数。
后来swprintf正式进入iso c99标准，但是函数声明却与windows内置的swprintf不一致！！！
结果就是微软被iso坑了啊…………..
但是此时微软已经发布了windows 95, windows 98…
那怎么办？要是直接把msvcrt.dll里面的swprintf改为iso标准的实现，那么以前基于旧版本开发的软件就没发运行了。
所以msvcrt.dll是肯定不能改的，后果很严重，但是又不能不兼容iso c标准的定义。
后来我查了vc++4.2和vc++6.0版本定义的swprintf都是和mingw一样的。
从vs2005开始才发生了变化，通过宏定义_CRT_NON_CONFORMING_SWPRINTFS，区分新旧版本swprintf。
如果定义了这个宏则使用旧版swprintf，没有定义则使用新版swprintf。
而新版swprintf其实是一个内联函数，在swprintf.inl文件中如下：
static __inline int swprintf(wchar_t * _String, size_t _Count, const wchar_t * _Format, ...)
{
    va_list _Arglist;
    int _Ret;
    _crt_va_start(_Arglist, _Format);
    _Ret = _vswprintf_c_l(_String, _Count, _Format, NULL, _Arglist);
    _crt_va_end(_Arglist);
    return _Ret;
}
看到这里，就恍然大悟了！！！
微软的程序员果然还真是聪明啊！！！这样既保证了软件兼容性，又可以实现兼容iso c99。
如果没猜错的话，目前所有版本的msvcrt.dll都是老版本的swprintf，所以才有今天mingw的头文件中swprintf的声明与iso c99不一致的问题。


怎样才能去除可执行文件中的.eh_frame数据?
Sun, 08 Jul 2018 20:24:22 +0000
用mingw gcc各个版本编译出来的exe文件，都比VS编译的大一点。
分析文件发现是每个exe文件都包含一个叫作".eh_frame"的节，然而却没有找到去除这个数据节的办法！！！
测试方法：
编译一个空的main.c文件，如下内容：
#include <stdio.h>
void main(void)
{
    printf("hello\n");
}
1.使用命令#gcc main.c 得到a.exe,这时包含调试信息，再用#strip a.exe去除调试信息。
发现a.exe里面也有.eh_frame章节。
2.使用命令#gcc -s main.c得到a.exe
这时a.exe还有是.eh_fram章节，注意与上面的a.exe有区别。
3.使用strip -R .eh_frame 强制去除这个数据节，结果程序不能正常运行了。
网上找了半天资料，试过加上如下各种参数：
-fno-exceptions
-fno-unwind-tables
-fno-asynchronous-unwind-tables
依然没能解决问题。

24小时后……
终于找到原因了，换了另外一个版本的gcc，编译出来的a.exe竟然没有.eh_frame段，而且体积会小2KB.
经过比较区别就是这个版本的gcc没有使用dwarf的异常模型！
使用gcc -v查看GCC的版本，会提示这个GCC的configure，如果带有–with-dwarf则说明是支持dwarf异常。
还记得Mingw-W64下载GCC的时候会选择线程模型(win32/posix)和异常模型(sjlj/dwarf)吗？
下载sjls异常的GCC编译出来的exe就没有.eh_frame！！！
之所以有这两种区别都是C++的事，只是没想到会影响我这个纯C开发者。
25小时后…………
事情好像不是我想像中的那样，似乎与异常模型没有关系？？？
因为我交换了两个版本GCC自带的win32 library之后，原本出现.eh_frame的GCC竟然没有出现！
进一步研究，好像是CRT库搞的鬼。具体就是crt1.o和crt2.o这两个文件！
使用ojbdump查看crt1.o，这是自带.eh_frame的那个版本：
$../bin/objdump.exe -h crt1.o

crt1.o:     file format pe-i386

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000500  00000000  00000000  00000294  2**4
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
  1 .data         00000004  00000000  00000000  00000794  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          0000001c  00000000  00000000  00000000  2**2
                  ALLOC
  3 .text.unlikely 00000000  00000000  00000000  00000000  2**2
                  ALLOC, LOAD, READONLY, CODE
  4 .CRT$XCAA     00000004  00000000  00000000  00000798  2**2
                  CONTENTS, ALLOC, LOAD, RELOC, DATA
  5 .CRT$XIAA     00000004  00000000  00000000  0000079c  2**2
                  CONTENTS, ALLOC, LOAD, RELOC, DATA
  6 .drectve      00000054  00000000  00000000  000007a0  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  7 .debug_info   00002203  00000000  00000000  000007f4  2**0
                  CONTENTS, RELOC, READONLY, DEBUGGING
  8 .debug_abbrev 00000441  00000000  00000000  000029f7  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_loc    000002e3  00000000  00000000  00002e38  2**0
                  CONTENTS, RELOC, READONLY, DEBUGGING
 10 .debug_aranges 00000020  00000000  00000000  0000311b  2**0
                  CONTENTS, RELOC, READONLY, DEBUGGING
 11 .debug_ranges 00000088  00000000  00000000  0000313b  2**0
                  CONTENTS, READONLY, DEBUGGING
 12 .debug_line   0000031c  00000000  00000000  000031c3  2**0
                  CONTENTS, RELOC, READONLY, DEBUGGING
 13 .debug_str    000002f0  00000000  00000000  000034df  2**0
                  CONTENTS, READONLY, DEBUGGING
 14 .rdata$zzz    0000002c  00000000  00000000  000037cf  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
 15 .eh_frame     000000c8  00000000  00000000  000037fb  2**2
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, DATA
下面是不带.eh_frame的版本


MSYS2使用笔记
Sat, 30 Jun 2018 15:12:28 +0000
MSYS2是一个体验非常好的linux模拟环境，可以移植大多数linux上面的程序，起源于cygwin。
虽然官方网站也提供了安装包，一键安装，但是整个软件包太大了，
我不太喜欢大而全的东西，更喜欢小而精的玩意。
这里有一个非常好的镜像网站，http://mirrors.ustc.edu.cn/msys2/
可以下载MSYS2的所有组件，以及所有版本，简直太好了。
下载runtime + coreutil + bash + mintty 就可以把框架运行起来了。
默认情况下bash的backspace不正常，需要下载ncurses-6.0，只要解压/usr/share/terminfo/78/xterm就可以了。
busybox也是个非常厉害的程序，只有500多KB，我打算用它提供的命令替换coreutil里面的东西，
然而发现它不支持中文，放弃之…
不过发现一个好玩的东西，linux下面的busybox –install 会以创建软链接的方式来调用不同的命令，
而windows平台却没有这样的操作，默认情况下是复制了N个相同的文件，硬盘占用感人！
虽然windows可以创建硬链接，但是给人的感觉还是不舒服，因为硬链接和普通文件太像了，根本看不出来，
查看文件夹大小，依然是一个很大的数字，为了减少磁盘空间，研究windows下面类似软链接的方法。
结果还真有：在windows命令行输入mklink ls busybox 就可以创建一个符号链接了。
文件图标有一个箭头，文件大小为0，可以双击运行，马上切换到MSYS2下面运行一下，成功！YES！太好了！！！


一阶IIR滤波器的C语言设计和优化
Tue, 17 Apr 2018 14:19:08 +0000
对于N阶IIR的计算方程式为：

其中N表示滤波器的级数，当N＝1的时候，其方程可以展开为如下所示：

本文的研究对象就是这个一阶方程，其中y为输出数据，x为输入数据，a和b为滤波器的系数。
x[n]为本次要滤波的输入数据，x[n-1]为上一次滤波前的输入数据，y[n-1]为上一次滤波器输出的数据。
设计这个滤波器，主要就是设计其中的系数a和b。
######################################
几乎网上的所有资料都是叫你使用matlab中的fdtool来设计参数，其实如果只是计算滤波参数，
完全不用安装matlab这个几百兆的大家伙，可以使用下面介绍的小工具完成任务：
1.直接在线计算：http://www-users.cs.york.ac.uk/~fisher/mkfilter
2.下载专用小软件ScopeIIR，官方网站：http://iowegian.com/scopeiir
3.下载专用小软件FiWiz，官方网站：http://www1.icsi.berkeley.edu/~storn/fiwiz.html
4.下载专用小软件Iowa Hill，官方网站：http://iowahills.com/8DownloadPage.html
#####################################
无论使用哪种方式计算参数，都要输入采样率，滤波器类型，滤波级数，截止频率等参数。
最后都会得到A0,A1,A2,B0,B1,B2这样的滤波器系数，直接代入到公式中计算就可以了。
默认情况下，公式中的数据用代码都是采用浮点数float或者double来计算，这样可以提高精度，
但是大量的浮点乘法计算量比较大，特别是对于主频不高的单片机而言就更为吃力；
所以我们希望可以使用定点整数以减少计算量，甚至希望用移位器和加法器来代替乘法。
下面就举一个实例来研究如何减少计算量：
我们要设计一个采样率为1000，截止频率为100，滤波器类型为Butterworth，阶数为1的IIR低通滤波器，
通过计算得到如下参数：
B[0]=+1.000000
B[1]=+1.000000
A[1]=-0.509525
(细心的人可能会发现高通滤波器和低通滤波器的区别只有B[1]这个参数，一个为+1.00，一个为-1.00)
代入公式得到：y[n]=x[n]+x[n-1]+0.509525*y[n-1]
我们优化的重点就是这个0.50952*y[n-1]，利用移位法来代替小数乘法，
原理就是把小数分解为1/M[0]+1/M[1]+…的方式，其中M[n]必须为2的整数次幂，
分解的次数越多，分母越大，误差就越小，可以根据实际情况需要选择分解的精度。
分解过程：
0.509525 * 1024 = 521(注：需要更高精度，可以把1024改为2048，4096，8192…….)
=521/1024
＝(512+8+1)/1024
=512/1024+8/1024+1/1024
=1/2+1/8+1/1024
所以这个公式可以改写为：y[n]=x[n]+x[n-1]+y[n-1]/2+y[n-1]/8+y[n-1]/1024
最后附上C语言代码：
/*************************************************************************************************
* 输入待滤波的数据，返回滤波后的数据
* 由于输入输出都是整型数据，为了防止数据溢出或数据太小，可以将输入数据先左/右移N位，最后返回时再右/左移N位
**************************************************************************************************/
int iir_filter(int x1)
{
    static int x0;
    static int y0;
    int y1;
    y1 = x1 + x0 + (y0>>1) + (y0>>3) + (y0>>10);
    x0 = x1;
    y0 = y1;
    return y1;
}



VirtLCD:在Windows上调试各种嵌入式GUI的小工具
Wed, 21 Mar 2018 12:48:24 +0000
前言
为了方便测试和移植嵌入式GUI，自己做的一个小工具，可以在windows上模拟出LCD，键盘和鼠标。
虽然像emwin一样，大多数GUI都提供了自己的模拟工具，但是一般只能用于它本身，不方便移植其它GUI或者自己开发GUI，所以写了这个通用工具，理论上支持移植任何GUI，当然主要是测试目的。
简介
本工具提供了LCD帧缓存以及鼠标和键盘接口，可以定制屏幕宽度，高度和颜色位深，支持16位，24位，32位色。
LCD窗口是在单独的进程中运行，在vs调试GUI的时候，可以单步调试，不会导致LCD窗口无法显示的问题。
VirtLCD.exe作为LCD窗口的服务器，VirtLCD.dll作为LCD窗口的客户端，同一时间只能运行一个LCD服务器。
LCD窗口服务器与客户端使用UDP传输按键和鼠标事件，而帧缓存使用内存映射技术，共享同一段内存。
LCD服务器定时将共享内存的数据绘制到屏幕上，目前刷新率设定为50Hz。
如何获取
本工具已经开放源代码，可以在码云下载完整源码，也可以下载打包好的SDK。
下载SDK压缩包： https://download.csdn.net/download/qq446252221/10299754
下载源代码： https://gitee.com/kerndev/VirtualLCD
如何使用
下面的代码作为演示.
/******************************************************************************
* LCD 驱动
******************************************************************************/
#include "virtlcd.h"

#pragma comment(lib, "virtlcd.lib")

#define LCD_FILENAME    "virtlcd.exe"
#define LCD_WIDTH       640
#define LCD_HEIGHT      480
#define LCD_BPP         32

//定义像素类型
typedef unsigned long   PIXEL;

//帧缓存指针
static PIXEL *m_pFrameBuffer;

//计算在X,Y坐标的帧缓存指针
#define GET_OFFSET(x, y)        ( LCD_WIDTH * ( LCD_HEIGHT - (y) - 1) ) + (x) )
#define GET_FRAMEBUFFER(x, y)   ( m_pFrameBuffer + GET_OFFSET(x, y) )

//响应鼠标事件
static void on_mouse_input(int event, int x, int y)
{

}

//响应键盘事件
static void on_keybd_input(int event, int key)
{

}

//初始化LCD
int LCD_Init(void)
{
    int ret;
    ret = VirtLCD_Init(LCD_FILENAME, LCD_WIDTH, LCD_HEIGHT, LCD_BPP);
    if(!ret)
    {
        return 0;
    }
    m_pFrameBuffer = VirtLCD_GetFrameBuffer();
    VirtLCD_SetMouseProc(on_mouse_input);
    VirtLCD_SetKeybdProc(on_keybd_input);
    return 1;
}

//画点
void  LCD_DrawPoint(int x, int y, PIXEL color)
{
    PIXEL *mem;
    mem = GET_FRAMEBUFFER(x, y);
    *mem = color;
}

//画水平直线
void  LCD_DrawHLine(int x1, int y1, int x2, PIXEL color)
{
    PIXEL *mem;
    mem = GET_FRAMEBUFFER(x1, y1);
    for(; x1 < x2; x1++)
    {
        *mem++ = color;
    }
}

//画垂直直线
void  LCD_DrawVLine(int x1, int y1, int y2, PIXEL color)
{
    PIXEL *mem;
    mem = GET_FRAMEBUFFER(x1, y1);
    for(; y1 < y2; y1++)
    {
        *mem = color;
        mem -= LCD_WIDTH;
    }
}



谈谈智能穿戴设备最火主控芯片NRF51422/NRF51822的开发感受
Tue, 13 Mar 2018 17:28:08 +0000
最近在接手一个nRF51822的项目，找到一篇文章，写得很有意思，总结非常通俗易懂，于是转过来了。
文章出处：http://blog.sina.com.cn/s/blog_9fff1f140102w87s.html
最近一年时间一直在做一个比较高端的运动设备的传感器——自行车功率计的开发，主控芯片自然选的是当前最火功能最强大的智能穿戴设备的SOC芯片NRF51422，跑蓝牙4.0和ANT+用于无线数据传输。经过这一年的折腾，基本算比较熟悉了，今天抽空总结总结对这款芯片的感受。
来个实物图~~
[ 
](http://photo.blog.sina.com.cn/showpic.html#blogid=9fff1f140102w87s&url=http://album.sina.com.cn/pic/002VF2gAgy70VHVJKDR67)
首先先大体介绍下这款芯片情况：
内核 ：ARM Cortex M0
主频 ：16MHz
内存 ：16/32KB
闪存 ：128/256KB
外设 ：UART，IIC，ADC，TIMER，SPI，RADIO，RTC，GPIOTE，TEMP,RTC
封装 ：48PIN QFN，也有超小超小的CSP封装的
[ 
](http://photo.blog.sina.com.cn/showpic.html#blogid=9fff1f140102w87s&url=http://album.sina.com.cn/pic/002VF2gAgy70VLQ6b9qe4)
从硬件上来看，基本就是一款自带2.4GHz射频无线收发器的MCU罢了。而主要特殊之处还是在软件上面，厂商提供了一套完善的蓝牙，ANT协议的处理代码，而这部分预先编译好，和用户应用部分程序分别烧录在芯片不同位置，彼此之间通过软件中断进行通信。相比于TI的CC254X系列提供源码和用户代码一起编译而言，这种方式更简洁，不容易出错，基本上协议栈程序和用户应用程序，虽然运行在一个处理器上，但基本处于类似井水不犯河水这种情况，无论是学习还是开发调试都带来了非常巨大的便捷，也无怪于成为目前最火热的智能可穿戴设备的主控SOC。
今天呢就主要讲讲硬件相关部分的感受~~~
首先先上Summary：
1、DCDC真有用，不是搞笑的
2、功耗控制略菜，要么浅睡，要么休眠启动就复位洗脑了
3、外设和端口连接可以随意映射，麻麻再也不用担心我布局布线啦
4、时钟体系8051feel，少挂不少脑细胞
5、各种外设易用功能少，寄存器配置傻瓜型，研发狗之友
6、定时器略菜，实时时钟调试器管不住，调试时候会坑成狗
7、IIC静态功耗有1mA，1mA，1mA！！不用赶紧关
8、温度外设有点搞笑的…….远看高端而已
供电：
和一般ARM Cotex M系列MCU差不多，都是1.8V~3.3V酱紫。也就是对于CR2032这种最常用纽扣电池而言是可以直接供电的，如果使用1节干电池或者可充电锂电池，就需要外围稳压芯片来升降压了。芯片实际内核工作电压就是1.8V。
比较特殊的在于这款芯片自己具有DCDC，即开关式稳压器，仅需外接一个电感一个电容就可以了。这个可以大大提高电源效率，对于寸电寸金的可穿戴智能设备而言是非常友好的一个设计。不过捏，很多人可能都没注意，这个DCDC其实仅能给片内的模拟部分提供电能，并且仅在无线收发器工作时候才开启，数字部分仍然是LDO，即线性稳压器提供。不过一般来讲，这种可穿戴设备也不需要多大运算量，绝大部分时候CPU都是睡眠的，因此这个也没多大影响。根据我们实测结果，跑蓝牙3.3v供电时候，峰值电流不开DCDC大概13个mA，开了之后差不多就9mA了，效果还是很明显的。
布局布线相关：
博主之前比较多时间都做STM32相关开发，那个引脚端口排布简直就跟随机分配一样。连接个啥LCD显示器，外扩内存闪存需要一排信号线过去时布局布线简直就是煎熬。NRF51422就非常友好，直接按顺序0-31排过去了。而且模拟信号相关的比如射频，晶振基本都在一侧，数字的在另一侧，布局布线相对都比较好处理，这个从图片里面也可以看出来。
然而最最最重要的，也是最最最特别的，就是外设和外端口的连接可以随意映射，而且是彻彻底底的随意映射（除ADC外），这个简直就是爽飞了啊，板子怎么安排走线都顺了，用了这个都有再也不想用其他MCU的感觉了哈哈哈哈。
下面谈谈芯片内部的~~来一发内部框图先
[ 
](http://photo.blog.sina.com.cn/showpic.html#blogid=9fff1f140102w87s&url=http://album.sina.com.cn/pic/002VF2gAgy70VLN2USu72)
时钟 ：
这个MCU时钟体系很简单，8051风格，16MHz跑遍全芯片，基本就不用管啦。一般芯片配置个时钟都要烧不少脑细胞，真心是研发狗之友啊哈哈。
功耗控制（PWR）：
就两种模式，System ON和System Off，前者都工作，后者都不工作，然后后者切换到前者之后系统等于复位了。这个略菜。一般MCU都是4，5种不同级别的低功耗模式，不少恢复了可以从休眠点继续跑。这个要达到这个效果只能保持在System ON模式，然后用CPU的WFI或者WFE让CPU停掉。Datasheet上面说可以到2.4uA，不过跑了协议栈之后咋都到不了了…..如果放在systemoff还要能唤醒之后继续跑，那就只能软件保存各种外设，CPU寄存器内容状态，然后开内存数据保存，然后再进入Off模式，复位之后自己判断情况来恢复，超级蛋疼。还好我们设备要求也没那么高，就前者搞掂了~~~后者的话，估计又得挂不少脑细胞。
无线收发器（RADIO）：
这个无线收发器还是非常易用的，基本可以看作是内嵌了一个NRF24L01。自带功放，外围接一个匹配网络之后直接接50欧姆阻抗的天线就完事了，基本不需要多少射频相关开发经验就可以达到不错的性能，只需要把走线的阻抗匹配好就可以。发射功率最大可以软件设置到+4dbm，基本上我们在楼道里面可以传个几十m都是妥妥的。
一般跑协议栈之后，这个外设就被MPU保护住不能访问了，也不需要管他。不跑协议栈时候，直接操作也是挺方便的，有一些简单数据传输，或者需要大吞吐量数据传输啥的，也可以自己直接操作。无线收发器内置了一个简易DMA用于数据传输，操作也很方便。
此外这个外设内部自带了一个信号强度检测的功能RSSI，拿来玩蓝牙定位啥的不错哦。
通用输入输出端口（GPIO，GPIOTE）：
端口模式很全，上拉下拉，开漏，推挽，模拟。需要注意的就是如果有外设连接到选定端口，基本上GPIO模块就管不了它了，也不需要去配置，配置也没用。外设和端口连接除ADC外可以随便映射，前面说过了，这个很爽。然后这里可以设置用GPIO唤醒MCU，不过只能高低电平唤醒，不能边沿唤醒。
然后GPIOTE算是GPIO的扩展吧，有一些没有直连GPIO的外设可以通过PPI再通过这个模块控制GPIO，比如反转，置低拉高的。此外也可以让GPIO以此控制这些外设，比如GPIO高低电平或者上升下降边沿触发外设执行某些操作啥的。这些具体在PPI里面讲了。
啥外设内部互联啥啥的（PPI）：
这个也算是这款芯片一个卖点吧，不过一般也就是一些功耗要控制非常非常非常非常低设备才有用的必要。这玩意大概是个啥情况捏，官方那破说明我也是看了老半天才看明白，其实炒鸡简单，且听我讲讲。
芯片内每个外设都有两种比较特殊的寄存器，里面只有一位可用。他们叫任务寄存器（Task）和事件寄存器（Event）。Task就像个按钮，给它写1就可以控制外设去开始一项任务，比如ADC转换一次，定时器捕获一次之类的。事件寄存器就像个灯泡，外设完成一项工作，比如ADC完成一次转换，GPIO捕获到一次下降沿，就点个灯。然后捏，PPI就是个通道，你可以随意配置源和端，就好比放了个人在这里看到亮灯就去按一下开关这种感觉，以此把外设工作串联起来。比如GPIO捕获到一个下降沿就开启一次模数转换，模数转换玩就触发一个GPIO反转啥啥的就自己去发挥啦。
这个还是很能玩的开的，有32个通道，而且各个通道开关本身都还是一个任务，可以组成很多很复杂操作。
这个好处呢，就是让CPU有更多时间睡眠，很多很简单的一系列连续工作就纯靠这个PPI内部机制来完成了，速度快，功耗低。此外很多外设内部还有很多short功能，和这个原理一样，只是将外设内部一些操作串联起来罢了。
模数转换器（ADC）：
8，9，10位可配置，貌似是逐次逼近型，功能也比较少，8通道输入，就能开启一次转换，然后获取数据，最多再开个中断。不像某STM32那个ADC单次连续扫描错位连续这个触发那个触发啥啥乱七八糟看得眼花缭乱的，这个基本几行代码就跑起来了。准确度的话还是非常不错的，跟我们安捷伦六位半的表比对，误差基本最多+-1，也就是千分之一酱紫，所以我们产品上面也直接就用片内的模数转换器来进行转换了。射频都能做的厂商，模拟肯定不在话下了哈哈。
此外这个功耗也还好，貌似仅转换时候有功耗，不使用的时候也没有多少必要去关掉它电源，也可能内部自动关的。
定时器（TIMER）：
这个也是MCU必备一个外设。不过51422这款的定时器功能也比较单一，简单来讲就捕获和比对俩功能，而且还要和GPIOTE结合在一起使用才能控制到外围管脚，要不然就自己在片内晃荡了。我用TIMER几乎就俩目的，一个产生个Tick中断用来定时触发啥啥的，这个一般就用ARM内核里面那个定时器就好，结果51422居然把这个阉掉了，也是无语。一个就是发生PWM拿来当DAC（数模转换）用。这个和GPIOTE结合起来也能实现硬件PWM，但问题很多，改PWM时候必须要重启定时器，比较坑。而还有个很奇葩的，居然这个定时器的计数寄存器是不能读取写入的，那好吧…….反正后面好像都没怎么用过这个了。


如何使用JLink:RTT打印调试日志
Fri, 02 Mar 2018 18:18:05 +0000
JLink 自V4.92版本以后，添加了RTT功能，可以在没有串口的时候当作调试日志输出端口。
一、准备工作
只需要在你的项目中添加以下三个文件：
SEGGER_RTT.c
SEGGER_RTT.h
SEGGER_RTT_Conf.h
需要注意的是在SEGGER_RTT_Conf.h中定义
#define SEGGER_RTT_IN_RAM (0)
这样不占用额外内存，即可实现日志打印；
在源码中调用SEGGER_RTT_Write(0, buff, len));
或者SEGGER_RTT_WriteString(0,str);
二、输出日志的查看方式


在Keil软件中使用JLink进入全速调试模式，然后打开JLinkRTTClient.exe就可以在控制台看到程序输出的内容；


直接使用JLinkRTTViewer.exe，可以在不进行全速调试模式的情况下查看输出的内容；


三、补充说明
1.如果Keil自带的Jlink驱动太旧，不支持RTT，则需要替换Keil自带的驱动文件:
在Keil\ARM\Segger\目录下面的JLink.exe, JLinkARM.dll, JLinkRDI.dll
2.实现RTT功能的关键在于JLinkARM.dll，在Keil进入调试模式时会加载JLinkARM.dll，而JLinkARM.dll会创建一个telnel服务器，监听端口是19021，所以可以用第三方telnel软件，如Secure-CRT软件来查看打印的日志更方便。


STM32F429同时使用LTDC和外部SDRAM作堆栈导致HardFault死机
Thu, 01 Mar 2018 09:51:12 +0000
最近在研究STM32F429的LTDC驱动LCD和emWin运行DEMO时候，发现程序总是异常死机，DEBUG发现是进入了HardFault！查看堆栈数据发现数据异常，难道是程序有BUG导致堆栈被破坏了吗？
于是新建一个最小工程，使用最精简的代码，只创建一个GUI线程跑emWin的DEMO程序，发现还是会不定时死机！难道是GUI线程的堆栈设置太小了吗？
于是加大GUI任务的堆栈，由8K增加到16K，故障依旧！！！不应该啊，难道是我的RTOS有问题吗？
于是去掉RTOS，修改emWin的配置文件，改为裸机运行，跑了一段时间，竟然不死机了！WTF!!!
于是又单独测试RTOS，去掉GUI任务反复测试，运行非常正常，各种测试代码都没有问题啊！！！
到底是怎么回事呢，为什么GUI和RTOS同时使用就会死机呢？
对比两份代码，区别就是使用RTOS的时候，把外部SDRAM用作了任务堆栈，而裸机程序使用的是内部RAM做堆栈。
于是把RTOS的任务堆栈设置为内部RAM，结果程序运行正常了！ 真是奇怪，难道STM32F429的SDRAM不能作堆栈吗？
不对，不对，不对，在移植GUI之前一直都是用外部SDRAM作任务堆栈，从来没有出现过这种死机的问题啊，难道是LTDC的问题吗？
于是又恢复刚才的代码，继续使用外部SDRAM作堆栈，但是去掉LTDC的初始化代码，再次运行程序，屏幕虽然没有任何显示，但是从板子上的不断闪烁的LED来看，程序并没有死机，继续观察10多分钟，也没有死机.
我的天！！！这是为何？？？
在启用LTDC之后，使用外部SDRAM用作堆栈会导致程序异常死机，至今没有找到原因。


使用iTunes下载旧版本的IPA文件
Thu, 16 Nov 2017 15:49:04 +0000
本文的方法参考: http://bbs.feng.com/read-htm-tid-10125110.html
本文的内容为自己理解后做下的记录.
方法说明:
本文介绍了一种使用iTunes下载旧版本的IPA文件的方法,
本方法的原理是通过Fidller抓包,拦截iTunes发起的HTTP请求, 并修改请求的内容,使得iTunes下载到的IPA文件为我们想要的旧版本.
一. 准备工作


安装Fiddler 4.6.2 (注:目前对版本没有要求,任意版本都可以)


安装.net framework 4.0


安装iTunes V12.6.2.20(注:新版本不能下载APP了)


二. 具体步骤
1.打开Fiddler, 勾选HTTPS解密,需要信任一个证书.
2.按下F12,停止抓包,然后最小化.


打开iTunes, 并用自己的apple id登陆iTunes.


打开iTunes的应用菜单, 进入App Store界面.


搜索目标APP程序,进入下载页面.


6.回到Fiddler,按下F12,开始抓包.
7.回到iTunes,开始下载该APP.
8.回到Fiddler,寻找带有"/WebObjects/MZBuy.woa/wa/buyProduct"字样的会话,
查看TextView,找到appExtVrsId注意下面的一串数字,该数字就是请求的软件版本ID,
然后Decode Response,并查看TextView,找到softwareVersionExternalIdentifiers,
下面有多行数字,表示这个APP的所有版本ID, 越往后版本越新,要下载旧版本就用旧版本的ID替换请求包体中的版本ID.
9.回到iTunes,APP资料库,删除刚才下载的APP,重新回到下载界面.
10.回到Fiddler,按下F11启动拦截功能.
11.回到iTunes,点击下载按钮,重新下载刚才的APP.
12.回到Fiddler,查看拦截列表,如果拦截到的不是"/WebObjects/MZBuy.woa/wa/buyProduct,则直接运行它,不拦截; 否则拦截下来,修改其中的版本ID,再继续运行.然后按下Shift+F11停止拦截功能.
13.等待iTunes下载完成,在资料库中,可以查看刚才下载的APP的版本号.
14.打开C:\Users\Administrator\Music\iTunes\iTunes Media\Mobile Applications就能找到下载好的ipa文件了.
三. 后记
在下载ipa的过程中,我发现iTunes下载有时候特别慢,所以用迅雷复制该ipa的下载链接,下载到了该ipa文件,速度非常快.
但是用iTools安装到手机后,显示LOGO后就闪退了,而用iTunes下载的则没有这个问题,
后来发现用迅雷下载的ipa文件与iTunes下载的ipa文件不一样,
用zip打开该文件可以看出来,迅雷下载的缺少iTunesArtworkt和iTunesMetadata.plist这两个文件,
其中后者实际上是一个xml文件,里面记录了下载这个ipa文件的appleid和版本信息.


研究Win32 GUI中SetActiveWindow与SetFocus和窗口消息
Thu, 31 Aug 2017 15:46:16 +0000
为了与Win32 GUI的函数功能兼容，得先知道Windows是怎么处理这些信息的，才能模仿。
这次研究对象是SetActiveWindow与SetFocus和窗口消息WM_SETFOCUS，WM_ACTIVATE之间的关系

SetFocus
功能：设置新的焦点窗口，只有焦点窗口才能获取键盘输入消息
1.这个函数会检查输入的窗口，如果是最小化的窗口，或者禁用的窗口，则不会改变焦点.
2.如果要设置的焦点窗口是子窗口，且其父窗口不是激活状态，还会调用SetActiveWindow将其父窗口激活.
3.检查激活窗口是否成功，如果没有成功，则取消设置新焦点.
4.向窗口发送WM_SETFOCUS消息，向前一个焦点窗口发送WM_KILLFOCUS消息

SetActiveWindow
功能：设置激活窗口，只有激活窗口，才能拥有焦点窗口
1.检查传入的窗口，如果是子窗口，则取消操作
2.向当前激活窗口发送WM_NCACTIVE消息，如果当前激活窗口返回FALSE，则表示它不同意其它窗口被激活，所以取消操作.
3.如果第2步没有问题，则向当前激活窗口发送WM_ACTIVE消息，告之被取消激活.
4.将传入的窗口标记为激活窗口，并将窗口的Z序置顶,
5.向新激活窗口发送WM_NCACTIVE和WM_ACTIVE消息，告之被成功激活.

WM_NCACTIVE
这个消息通知窗口，非客户区被激活或取消激活.
当WPARAM参数为FALSE时，表示窗口要被取消激活，此时如果返回FALSE，则会阻止被取消激活，返回TRUE则表示允许被激活。
DefWindowProc 处理方式：做一些内部标记，如果lParam为－1的话，还要重绘标题栏和菜单栏！
WM_SETFOCUS
这个消息是通知窗口，即将获得或失去焦点；
DefWindowProc好像并没有处理这个消息。
WM_ACTIVATE
这个消息是通知窗口，即将被激活或取消激活；
DefWindowProc 处理方式是：如果这个窗口马上要被激活了，则将这个窗口设置为焦点窗口

这里很诡异的是，如果对一个未激活的主窗口调用SetFocus，它会激活这个窗口，
而激活这个窗口会发送WM_ACTIVE消息，而默认处理WM_ACTIVE消息的方式又是对这个窗口调用SetFocus…


验证RA8875的硬件绘图与使用MCU软件绘图的速度差异
Wed, 30 Aug 2017 21:33:21 +0000
RA8875是一块LCD驱动芯片，支持RGB接口的LCD液晶屏，提供8080时序的MCU接口；
RA8875内置了2D硬件加速功能，可以实现硬件绘制矩形，直线等功能；
本次测试就是为了验证RA8875的硬件绘图与使用MCU软件绘图的速度差异。
硬件环境：
CPU：STM32F407VE@168MHz
LCD：480x272x16bpp
测试方法：
计算1秒内填充整个屏幕的次数(FPS)
测试结果：

  
      
          填充方式
          帧率(FPS)
          速度(Pixel/s)
          备注
      
  
  
      
          软件逐点填充
          6
          783360
          
      
      
          软件逐行填充
          63
          8225280
          
      
      
          软件矩形填充
          69
          9008640
          
      
      
          硬件逐行填充1
          201
          26242560
          先绘图，等待空闲后退出函数
      
      
          硬件逐行填充2
          207
          27025920
          进入函数先等待空闲，再绘图
      
      
          硬件矩形填充1
          312
          40734720
          先绘图
      
      
          硬件矩形填充2
          315
          41126400
          先等待
      
      
          
          
          
          
      
      
          emWin(5.30)
          126
          16441000
          自带驱动，支持硬件加速
      
      
          FastGUI
          201
          26242560
          驱动为硬件逐行填充2
      
      
          FlatGUI
          324
          42301440
          
      
  

说明：RA8875的硬件绘制功能，需要读取状态寄存器的BIT7，
如果该位为1说明硬件绘制没有完成，不能进行其它绘制，否则屏幕会显示不正常。
“先绘图”是指先发送硬件绘图指令，然后读取状态寄存器，等待BIT7清0后退出函数；
“先等待”是指先读取状态寄存器，等待BIT7清0后，再发送绘图指令；
测试结论：
由此可见使用RA8875的硬件绘图有着非常明显的速度优势，比使用软件绘图快了3－4倍。
附上RA8875的2D加速代码：
static void lcd_set_rect(int x1, int y1, int x2, int y2)
{
    //窗口起始位置
    lcd_command(0x30, x1);
    lcd_command(0x31, (x1 >> 8) & 0x3);
    lcd_command(0x32, y1);
    lcd_command(0x33, (y1 >> 8) & 0x01);

    //窗口结束位置
    lcd_command(0x34, x2);
    lcd_command(0x35, (x2 >> 8) & 0x03);
    lcd_command(0x36, y2);
    lcd_command(0x37, (y2 >> 8) & 0x01);
}

static void lcd_wseek(int x, int y)
{
    lcd_command(0x46, x);
    lcd_command(0x47, x >> 8);

    lcd_command(0x48, y);
    lcd_command(0x49, y >> 8);
}

static void lcd_rseek(int x, int y)
{
    lcd_command(0x4A, x);
    lcd_command(0x4B, x >> 8);

    lcd_command(0x4C, y);
    lcd_command(0x4D, y >> 8);
}

void lcd_set_pixel(int x, int y, int pixel)
{
    lcd_wait_ram();
    lcd_wseek(x, y);
    lcd_command(0x02, pixel);
}

int lcd_get_pixel(int x, int y)
{
    int data;
    lcd_rseek(x, y);
    LCD_CMD = 0x02;
    data = LCD_DATA;  //dummy read
    data = LCD_DATA;
    return data;
}

//BTE
static void bte_set_rect(int x, int y, int w, int h)
{
    lcd_command(0x58, x);
    lcd_command(0x59, (x >> 8) & 0x03);
    lcd_command(0x5A, y);
    lcd_command(0x5B, (y >> 8) & 0x01);

    lcd_command(0x5C, w);
    lcd_command(0x5D, (w >> 8) & 0x03);
    lcd_command(0x5E, h);
    lcd_command(0x5F, (h >> 8) & 0x03);
}

static void bte_set_bkcolor(int color)
{
    lcd_command(0x60, (color >> 11) & 0x1F);
    lcd_command(0x61, (color >> 5) & 0x3F);
    lcd_command(0x62, color & 0x1F);
}

static void bte_set_fgcolor(int color)
{
    lcd_command(0x63, (color >> 11) & 0x1F);
    lcd_command(0x64, (color >> 5) & 0x3F);
    lcd_command(0x65, color & 0x1F);
}

static void bte_set_colorkey(int color)
{
    lcd_command(0x67, (color >> 11) & 0x1F);
    lcd_command(0x68, (color >> 5) & 0x3F);
    lcd_command(0x69, color & 0x1F);
}

static void bte_open(int mode)
{
    lcd_command(0x51, lcd_rop_mask | mode);
    lcd_command(0x50, 0x80);
}

static void g2d_set_rect(int x, int y, int x2, int y2)
{
    lcd_command(0x91, x&0xFF);
    lcd_command(0x92, (x>>8)&0xFF);
    lcd_command(0x93, y&0xFF);
    lcd_command(0x94, (y>>8)&0xFF);
    
    lcd_command(0x95, x2&0xFF);
    lcd_command(0x96, (x2>>8)&0xFF);
    lcd_command(0x97, y2&0xFF);
    lcd_command(0x98, (y2>>8)&0xFF);
}

static void g2d_command(uint8_t cmd)
{
    lcd_command(0x90, cmd);
}

void lcd_set_rop(int mode)
{
    lcd_rop_mask = (mode & 0x0F) << 4;
}

void bte_fill_rect(int x, int y, int w, int h, int color)
{
    lcd_wait_bte();
    bte_set_rect(x, y, w, h);
    bte_set_fgcolor(color);
    bte_open(0x0C);
}

void g2d_fill_rect(int x, int y, int x2, int y2, int color)
{
    lcd_wait_ram();
    bte_set_fgcolor(color);
    g2d_set_rect(x, y, x2, y2);
    g2d_command(0xB0);
}



Windows系统使用WMIC的获取硬盘ID的问题
Wed, 30 Aug 2017 14:03:40 +0000
为了查询硬件信息，可以使用wmic命令：
查看CPU：wmic cpu get processorid
查看主板：wmic baseboard get serialnumber
查看硬盘：wmic diskdrive get serialnumber
但这里有个小问题：
对于XP系统查不到硬盘ID；
对于win7系统硬盘ID是HEX格式的文本(40位)，如：202020202020325a4b415244544；
对于win10系统硬盘ID是字符串格式，如：XYZ1234567890；
对于win8.1系统和win10一样.
对于win8和vista没有裸机测试,所以结果未知.
对于有多块硬盘的系统，wmic列出的硬盘顺序可能是乱的, 目前不知道排序规则，可以肯定的是排在第1个的不一定就是当前系统盘；(猜测可能是BIOS中的启动顺序???)
Windows的物理硬盘序号\.\PHYSICALDRIVE0-X是按照主板接口顺序(SATA0-X)排序的，PHYSICALDRIVE0不一定是当前启动系统的那块硬盘.
那么如何得知当前系统所在的硬盘呢,并读取硬盘ID呢?
目前看来,可以假定当前系统盘一定是C盘,所以通过读取C盘的磁盘信息,获取C盘所在磁盘的编号,这个编号就是\.\PHYSICALDRIVEx中的x;
如果想查看该硬盘的信息，可以使用：wmic diskdrive where deviceid=’\\.\PHYSICALDRIVEx'


嵌入式操作系统内核KLite的API详解
Mon, 14 Aug 2017 14:18:23 +0000
本文转载出处：http://git.oschina.net/kerndev/klite/wikis/API%E6%89%8B%E5%86%8C
#KLite API参考手册
##1.功能特性 KLite是一个为ARM Cortex-M微控制器设计的微内核,设计思想是"简洁易用".
-1- 支持动态内存管理;
-2- 支持256级线程抢占优先级;
-3- 支持线程同步:互斥锁,信号量,事件.
-4- 规范的编码风格.
##2.数据类型 KLite提供以下4种内核对象:
kthread_t 线程标识符
kmutex_t 互斥锁标识符
kevent_t 事件标识符
ksem_t 信号量标识符
##3.API参考 ###3.1 内核相关
原型: 
	void kernel_init(uint32_t addr, uint32_t size)
功能: 
	KLite内核初始化.
参数: 
	addr    内核动态管理内存起始地址
	size    内核动态管理内存大小  
返回值: 
	无
备注:在调用内核初始化时保证中断处于关闭状态,此函数只能执行一次,在初始化内核之前不能调用任何KLite相关的API.
原型: 
	void kernel_start(void)
功能: 
	启动KLite内核,内部调用底层函数cpu_tick_init,以启动滴答定时器.
参数: 
	无 
返回值: 
	无
备注:
	在启动KLite之前调用至少需要创建一个用户线程.
原型:
	uint32_t kernel_version(void)
功能:
	返回KLite内核的版本号
参数:
	无
返回值:
	版本号,BIT[31:24]主版本号,BIT[23:16]次版本号,BIT[15:0]修订号
原型:
	uint32_t kernel_time(void)
功能:
	返回内核自启动以来的节拍数,单位毫秒
参数:
	无
返回值:
	节拍数
###3.2 内存管理


在MSYS2+MinGW环境下编译arm-none-eabi工具链
Tue, 08 Aug 2017 17:37:55 +0000
前言
在Windows平台有MSYS2这个非常好用的linux模拟环境，支持大量的linux实用工具，如：busybox, grep, find, sed, awk, perl, gcc等等. 虽然MSYS2平台也提供了gcc编译器，但它的gcc工具链是i686-pc-msys，也就是说它编译出来的代码是基于MSYS的运行时环境， 而不是原生的Windows运行时(MSVCRT)，所以为了编译Windows平台运行的EXE程序，还是使用MINGW提供的GCC比较好。
目的
MSYS和MINGW都提供了各自的gcc工具链，但是没有arm平台的交叉编译环境，所以自己尝试编译一个单纯的arm-none-eabi工具链。
正文
在MSYS+MINGW环境下编译gcc和在linux系统编译过程大体相同，
编译顺序也是这样的：gmp -> mpfr -> mpc ->binutils -> gcc （-> glibc -> binutils -> gcc）。
注意：不要用太新的GCC版本编译太旧的GCC源码，我之前用GCC6.3编译4.8版本的源码失败了。
我现在测试使用的是GCC5.10， 编译的源码版本为4.8.5。
1.编译gmp, mpfr, mpc
#../configure --disable-shared --host=i686-pc-mingw32 --build=i686-pc-mingw32 --prefix=/opt/mingw
#make
#make install
编译过程都比较顺利
host 指定运行这个库的环境是mingw32
build 指定编译这个源码的环境是mingw32
可能会出现找不到gmp.h的问题，那就添加一个参数：–with-gmp=/opt/mingw
这里不能用动态链接，所以要–disable-shared
2.编译binutils
#../configure --disable-shared --disable-nls --disable-multilib --host=i686-pc-mingw32 --build=i686-pc-mingw32 --target=arm-none-eabi --prefix=/opt/arm
# make
# make install
这个编译过程也比较顺利，可能出现的问题问题同上。
3.编译gcc：
#../configure --enable-targets=all --enable-languages=c --disable-shared --disable-checking --disable-threads --disable-multilib --disable-nls  --disable-decimal-float --disable-libgomp --disable-libmudflap --disable-libssp --disable-bootstrap --disable-libquadmath --disable-libatomic  --without-headers --with-newlib
--host=i686-pc-mingw32 --build=i686-pc-mingw32 --target=arm-none-eabi
#make -j2
#make install
编译gcc非常慢，而且还出了几个问题，在此记录：


在MSYS2+MinGW环境下编译arm-none-eabi工具链
Tue, 08 Aug 2017 17:24:55 +0000
前言
在Windows平台有MSYS2这个非常好用的linux模拟环境，支持大量的linux实用工具。
如：busybox, grep, find, sed, awk, perl, gcc, make等等.
虽然MSYS2平台也提供了gcc编译器，但它的gcc工具链是i686-pc-msys，
也就是说它编译出来的可执行文件是基于MSYS2的运行时环境，需要msys.dll才能运行。
而不是原生的Windows运行时(MSVCRT)，所以为了编译Windows平台运行的EXE程序，
还是使用MINGW提供的GCC比较好。
目的
MSYS2和MINGW都提供了各自的gcc工具链，但是没有arm平台的交叉编译环境，
所以自己尝试编译一个单纯的arm-none-eabi工具链。
正文
在MSYS2+MINGW环境下编译gcc和在linux系统编译过程大体相同，
编译顺序也是这样的：gmp -> mpfr -> mpc ->binutils -> gcc （-> glibc/newlib/uclibc）。
注意：
不要用太新的GCC版本编译太旧的GCC源码，我之前用GCC6.3编译4.8版本的源码失败了。
我现在测试使用的是GCC5.10， 编译的源码版本为4.8.5。
编译时，最好在源码目录下执行:
#mkdir build
#cd build
#../configure
这样不会污染源码目录。
1.编译gmp, mpfr, mpc
#../configure --host=i686-pc-mingw32 --build=i686-pc-mingw32 --prefix=/opt/mingw --disable-shared 
#make
#make install
或者 
#make install-strip
编译过程都比较顺利，此过程需要MSYS2有m4、awk、grep命令。
–host 指定运行这个库的环境是mingw32
–build 指定编译这个源码的环境是mingw32
可能会出现找不到gmp.h的问题，那就添加一个参数：–with-gmp=/opt/mingw
这里不能用动态链接，所以要–disable-shared
2.编译binutils
#../configure --host=i686-pc-mingw32 --build=i686-pc-mingw32 \
--target=arm-none-eabi --prefix=/opt/arm \
--disable-shared --disable-nls --disable-multilib 
#make CFLAGS="xxx"(这里可以自定义编译选项)
#make install
#make install-strip(推荐)
这个编译过程也比较顺利，一般不会有什么问题。


[MSYS]另类busybox调用/安装方法
Tue, 08 Aug 2017 13:05:56 +0000
在Windows环境下的使用MSYS2，由于Windows上面不支持ln -s这样的软链接，
默认情况下，如果使用busybox –install 这样的话，busybox会把自己复制N遍，每个命令都是一个exe文件，且文件大小等于它自己。
这样的话就浪费用了大量的磁盘空间，于是我研究了一下，找到一种可以节省空间的调用方法，如下：
在/usr/bin目录下面，建立该命令的shell脚本，
比如我需要busybox的cpio命令，则新建一个文件名为cpio的脚本。
内容为：
#!/usr/bin/busybox
"$0" "$@"
第一行指定了解释这个脚本的程序，由busybox来执行
第二行 “$0” 代表文件名自己，"$@“代表调用参数。
可以把这个文件改名为任何busybox支持的命令。
是不是很方便了呢，哈哈哈？


关于cygwin/msys/msys2/mingw/mingw64
Sat, 05 Aug 2017 16:12:15 +0000
最近想在windows平台建立一个gcc开发环境，目前windows平台有多种gcc工具链可用：cygwin/msys/msys2/mingw/mingw64
这几天研究了一下这几个东西，把目前所了解的情况做个笔记,以防以后再花时间去研究.
cygwin
是最早出现的一套在windows平台模拟linux环境的软件，它几乎完整地模拟了linux的大部分API，
核心文件是cygwin1.dll，然后再基于此核心移植了linux平台的其它GNU工具.
工具比较全，体积较大，运行速度较慢，编译的程序依赖cygwin.dll.
所以说它应该可以理解为一个linux模拟器.
主页： http://www.cygwin.com/
mingw
则是专注于windows平台的gcc工具链，把gcc移植到windows平台，基于原生win32 api，而不依赖linux平台的api.
它不提供linux环境下的其它管理工具，是个原生的windows编译环境.
可以用它编译出原生的windows程序，而不像cygwin一样需要依赖cygwin.dll.
它的gcc工具命名是 i686-pc-mingw32-gcc
主页： http://www.mingw.org/
项目资源： https://sourceforge.net/projects/mingw
mingw-w64
由于mingw只支持32位程序，所以又产生了mingw-w64，提供了可以在32位系统上编译出64位windows程序的gcc工具链？
它的gcc工具命名是i686-w64-mingw32-gcc还有x86_64-w64-mingw32-gcc
主页： http://www.mingw-w64.org/
项目资源： https://sourceforge.net/projects/mingw-w64
msys
由mingw团队开发的，mingw和cygwin结合的产物，cygwin的精简版再加上mingw的编译器.
主要是用来配合mingw进行命令行开发一套比较完整的开发环境.
主页： http://www.mingw.org/wiki/MSYS
msys2
是另一个开源组织在MSYS的基础上重新开发的.与MSYS最大的区别是移植了 Arch Linux 的软件包管理系统 Pacman
msys2也和cygwin差不多，是模拟linux平台的环境(posix api)，但它的速度比cygwin要快不少.
目前提供了比较丰富的工具，包括git, python, perl, gcc等。
用它的gcc编译出来的程序，需要msys2的运行环境，核心dll是msys-2.0.dll
gcc工具命名是 i686-pc-msys-gcc
主页是： http://www.msys2.org/
下载源： https://sourceforge.net/projects/msys2/
写在最后：
目前推荐使用的mingw-w64和msys2的组合.
mingw的工具链适合编译纯windows api的程序，而sys2则可以比较方便地移植GNU的开源项目.
目前git for windows从安装后的文件目录来看，也是基于msys2的，但它的git是由mingw32编译的.
由于我又想要使用mingw,又想使用msys2，又想使用git，如果分开安装，不仅占用硬盘空间，而且很麻烦，
所以我想在windows上使用MSYS2来统一开发环境，我安装了MSYS2，再安装了MSYS2提供的git，
但发现这个版本的git在以http的方式clone远程仓库时输入用户名没有回显，很奇怪，很纠结.


怀念WAP网站和让IE浏览器支持WAP网站
Tue, 02 May 2017 13:41:29 +0000
前言
WAP网站目前已经快要消失了，对于WAP那真是满满的回忆啊，10年前那个让人激动的网站：wap.3g.qq.com，现在早已经无法访问了。
WAP网站那时候还是主流的手机网站，因为页面内容少，节省流量，对手机性能要求也非常低。
1.0版本的WAP主要使用wml语言做为网页开发语言，到了2.0版本则使用xhtml，新旧版本在那个时候体现在“普通版”和“彩版”的切换。
普通版本则是完全基于WML语言，主要是文字和少量gif图片，排版也比较简单，基本都是左对齐；
彩色版则是使用XHTML语言，文字有了颜色，按钮也有了背景框，文本也有居中显示了；
现代版的手机网站基本都使用HTML5开发，网页内容就非常丰富了而且支持javascript，网页广告则堆一堆的出现，对手机性能要求的流量也比以前高了许多！
所以现在用30MB手机流量上网？基本看不了几个网页就被广告和图片消耗完毕了，想想曾经一个月30MB流量可以玩一个月的岁月，真的是十分怀念的！！！
下面是三种效果的百度首页，分别是：简版（WML）、彩色版（XHTML）、现代版（H5）！







前两种百度首页，只需要不到10KB的流量，而H5版本的百度首页，则需要几百KB的流量！
我个人最喜欢的是第2种页面，也就是所谓的彩版页面，既简洁又省流量。
正文
说了这么多废话，该上正文了，我最近发现不管是chrome还有IE浏览器，其实它们都可以解析并显示WML语言的页面。
但是联网访问这些页面的时候，它并不能正确识别这种格式所以会导致不能正常显示，对于chrome浏览器，我没有找到办法让它重新认识这种格式。
但IE浏览器可以，只要导入下面的注册表内容就可以实现了！
Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\MIME\Database\Content Type\text/vnd.wap.wml]
"Extension"=".wml"
"Encoding"=hex:08,00,00,00
"CLSID"="{25336920-03F9-11cf-8FD0-00AA00686F13}"

[HKEY_CLASSES_ROOT\.wml]
@="htmlfile"
"Content Type"="text/html"
"PerceivedType"="text"


[HKEY_CLASSES_ROOT\.wml\OpenWithProgids]
"htmlfile"=""


[HKEY_CLASSES_ROOT\.wml\PersistentHandler]
@="{eec97550-47a9-11cf-b952-00aa0051fe20}"



BIOS引导流程与启动管理器
Tue, 28 Mar 2017 11:34:49 +0000
现今BIOS存在传统的Legacy BIOS和UEFI两种；
Legacy BIOS
存在的历史比较长，使用广泛，最近几年正在被UEFI所替代，主要原因我认为是这种方式的BIOS对X64体系的支持不够友好；
再加上硬盘容量已经超过2TB，MBR分区表无法处理，需要用到GPT分区表.
Legacy BIOS的一般启动流程是:
1.由BIOS选择启动设备，如HDD/CDROM等；
2.加载该设备的MBR（主引导记录），MBR中记录了下一步启动的方式，通常是搜索激活的主分区；
3.加载该分区的PBR（分区引导记录），PBR中记录了需要引导分区中的哪个启动管理器，如NTLDR/BOOTMGR/GRLDR等；
4.加载启动管理器，由启动管理器进一步加载OS内核；
UEFI
全称“统一的可扩展固件接口”(Unified Extensible Firmware Interface)， 是一种详细描述类型接口的标准。
这种接口用于操作系统自动从预启动的操作环境，加载到一种操作系统上。
大约2010年以后生厂的电脑大多数都开始使用UEFI了，只不过版本可能比较低，兼容性没有最近几年的好。
UEFI的启动流程：
1.指定启动设备，如HDD/CDROM等；
2.搜索可识别的分区，通常是FAT32；
3.在该分区的/efi/boot/目录下寻找bootx64.efi或者bootia32.efi；
4.引导bootx64.efi文件，这个文件就是Legacy BIOS中的启动管理器，由启动管理器进一步加载OS内核；
虽然UEFI在各个方便对比传统BIOS有不少优势，但目前看来使用起来还是有不少困难，比如说支持的引导程序比较少，不支持实模式的DOS系统等。
而且Legacy BIOS和UEFI的运行模式完全不一样，引导文件的格式也不一样，因此在Legacy BIOS和UEFI模式下的引导文件是不能通用的。
再加上MS在UEFI中强行加入Secure Boot这个流氓，啊？

启动管理器（也叫做引导程序，对应的文件叫做引导文件）
常见的启动管理器如下：
1.NTLDR
Windows XP时代的启动管理器，通过/boot.ini文件来管理启动菜单，可以引导grub等其它引导程序。
目前只有Legacy BIOS模式下的引导文件，不支持UEFI启动。
2.BOOTMGR
Windows Vista以后的系统使用和启动管理器，功能上比NTLDR强大一些，支持VHD，WIM文件的挂载。
Legacy BIOS模式下引导文件为/bootmgr，通过/boot/bcd文件来管理启动菜单；
UEFI模式下引导文件为/efi/boot/bootx64.efi，通过/efi/microsoft/boot/bcd文件来管理启动菜单。在UEFI环境下它不能引导其它的启动管理器如grub。
3.GRUB4DOS
多系统引导程序，GNU GRUB的一个分支，有一个强大的shell，可以通过命令行进行引导。
目前只有Legacy BIOS模式下的引导文件，不支持UEFI启动，一般情况下通过/menu.lst来管理启动菜单；
常用命令:
chainloader 加载MBR
chainloader /bootmgr 可以导引bootmgr
chainloader /g2ldr.mbr 可以引导grub2;
chainloader +1 可以引导当前分区的PBR;
kernel 加载引导程序内核
kernel /g2ldr 可以引导GRUB2;
boot 引导刚才加载的程序;
map 映射iso等镜像文件;


Makefile参考样例4：多个文件夹.c的编译
Fri, 24 Mar 2017 16:01:58 +0000
对于上一篇的makefile的缺点，经过改良后行成了下面的makefile；
主要改动是把编译过程的中间文件(*.d, *.o)放到一个单独的文件夹，clean的时候删除该中间文件夹，不会污染源码文件夹。
优点：代码简洁，容易解理，能自动检查头文件依赖关系，支持不同文件夹下面有相同的文件名的.c文件，中间文件单独存放；
缺点：暂无
#这是一个makefile的参考样例,用于编译多文件夹,多文件
#编译工具链
CC	= gcc
CXX	= g++
LD	= $(CC)
AS	= nasm

#编译选项
ASFLAGS  = -m32
CFLAGS   = -m32 -Wall $(incdir)	 
CXXFLAGS = -m32 -Wall $(incdir)
LDFLAGS	 = -m32 -static

#定义输出文件名
target = main.exe

#定义根目录
objdir = obj
srcdir = src

#定义源码子目录
subdir = . \
         src \
		 dir1 \
		 dir2 \
		 dir2/sub1 \
		 dir2/sub2

#定义包含目录
incdir = $(foreach dir, $(subdir), -I$(srcdir)/$(dir))

#定义附加依赖库
inclib = -lpthread

#遍历所有dir,并搜索该dir下面的所有.c文件
allsrc = $(foreach dir, $(subdir), $(wildcard $(srcdir)/$(dir)/*.c))

#把所有的.c替换为.o
allobj = $(patsubst $(srcdir)/%.c, $(objdir)/%.o, $(allsrc))

#把所有的.c替换为.d
alldep = $(patsubst $(srcdir)/%.c, $(objdir)/%.d, $(allsrc))

#生成.d的规则
$(objdir)/%.d: $(srcdir)/%.c
	@echo Generating $@...
	@$(CC) -MM -MT "$(patsubst $(srcdir)/%.c, $(objdir)/%.o, $<) $@" $(CFLAGS) $< >$@
	
#生成.o的规则
$(objdir)/%.o: $(srcdir)/%.c
	@echo Compiling $<...
	@$(CC) $(CFLAGS) -c $< -o $@
	
#如果是第3次调用make,则包含所有.d文件	
ifeq ($(MAKELEVEL), 2)
include $(alldep)
endif
	
#声明虚拟目标
.PHONY:	init clean

init: 
	@mkdir -p $(dir $(allobj))
	@$(MAKE) -s depend
	
depend: $(alldep)
	@$(MAKE) -s target

target: $(alldep) $(allobj)
	@echo Linking target...
	@$(LD) $(LDFLAGS) -o $(target) $(allobj) $(inclib)
	@echo Link done!
	
clean:
	@rm -rf $(target) $(objdir)
	@echo clean done.



Makefile参考样例3:多个文件夹.c的编译
Fri, 24 Mar 2017 10:37:45 +0000
上一篇的Makefile写得太过复杂，且不支持同名.c文件，因此经过改良后，又来一发Makefile参考样例3；
优点：代码简洁，容易解理，能自动检查头文件依赖关系，支持不同文件夹下面有相同的文件名的.c文件；
缺点：所有编译的中间文件与源码在同一路径，会造成一些文件污染，好在make clean可以干净地清除这些中间文件；
代码如下：
#这是一个makefile的样例,用于编译多文件夹,多文件的编译

#编译工具链
CC	= gcc
CXX	= g++
LD	= $(CC)
AS	= nasm

#编译选项
ASFLAGS  = -m32
CFLAGS   = -m32 -Wall $(incdir)	 
CXXFLAGS = -m32 -Wall $(incdir)
LDFLAGS	 = -m32 -static

#定义输出文件名
target = main.exe

#定义源码目录
srcdir = src \
         src/dir1 \
         src/dir2 \
         src/dir2/sub1 \
         src/dir2/sub2

#定义包含目录
incdir = $(foreach dir,$(srcdir),-I$(dir))

#定义附加依赖库
inclib = -lpthread

#遍历所有dir,并搜索该dir下面的所有.c文件
allsrc = $(foreach dir,$(srcdir),$(wildcard $(dir)/*.c))

#把所有的.c替换为.o
allobj = $(allsrc:%.c=%.o)

#把所有的.c替换为.d
alldep = $(allsrc:%.c=%.d)

#生成.d的规则
%.d: %.c
	@echo Generating $@...
	@$(CC) -MM -MT "$(<D)/$(*F).o $@" $(CFLAGS) $< >$@
	
#生成.o的规则
%.o: %.c
	@echo Compiling $<...
	@$(CC) $(CFLAGS) -c $< -o $@


#如果不是第1次调用make,则包含所有.d文件	
ifneq ($(MAKELEVEL), 0)
include $(alldep)
endif

#声明虚拟目标
.PHONY:	init clean

init: $(alldep)
	@$(MAKE) -s $(target)

ifneq ($(MAKELEVEL), 0)
$(target): $(alldep) $(allobj)
	@echo Linking target...
	@$(LD) $(LDFLAGS) -o $@ $(allobj) $(inclib)
	@echo Link done!
endif

clean:
	@rm -rf $(alldep) $(allobj) $(target)
	@echo clean done.



Makefile参考样例2:多个文件夹.c的编译
Thu, 23 Mar 2017 17:08:29 +0000
优点：可以很好地解决.h头文件依赖问题，修改任意头文件，会自动重新编译对应的c文件；
缺点：在不同的文件夹下面不能有同名的c文件!
源码目录结构如下：
src
├─main.c
├─dir1
│　├─file11.c
│　├─file11.h
│　├─file12.c
│　└─file12.h
└─dir2
    ├─sub1
    │  ├─file211.c
    │  ├─file211.h
    │  ├─file212.c
    │  └─file212.h
    └─sub2
        ├─file221.c
        ├─file221.h
        ├─file222.c
        └─file222.h
这个Makefile理解起来有点麻烦，Make进行了递归调用,第1次生成depend文件，第2次进行编译和链接.代码如下：
#|这是一个makefile的范例,用于编译多文件夹,多文件的编译

#定义编译工具链
CC	= gcc
CXX	= g++
LD	= $(CC)
AS	= nasm

#编译选项
ASFLAGS  = -m32
CFLAGS   = -m32 -Wall $(incdir)	 
CXXFLAGS = -m32 -Wall $(incdir)
LDFLAGS	 = -m32 -static

#定义输出文件名
target = main.exe

#定义输出根目录
objdir = obj/

#定义源码根目录
srcdir = src/

#定义所有的文件夹和需要编译的目标文件
alldir = . dir1 dir2 \
	     dir2/sub1 dir2/sub2

#定义所有文件
allsrc = main.c\
         file11.c file12.c\
         file211.c file212.c\
		 file221.c file222.c

#定义头文件包含目录
incdir = $(foreach dir,$(alldir),-I$(srcdir)$(dir))

#定义连接依赖库
inclib = -lpthread

#配置搜索路径
vpath %.c	$(foreach dir,$(alldir),$(srcdir)$(dir)/ )
vpath %.h	$(foreach dir,$(alldir),$(srcdir)$(dir)/ )
vpath %.o 	$(foreach dir,$(alldir),$(objdir)$(dir)/ )
vpath %.d 	$(foreach dir,$(alldir),$(objdir)$(dir)/ )

#所有依赖关系
autdep = $(allsrc:.c=.d)
autobj = $(allsrc:.c=.o)

#所有目标
allobj = $(foreach file,$(allsrc), \
		 $(foreach dir,$(alldir),$(subst $(srcdir),$(objdir), \
		 $(firstword $(subst .c,.o,$(wildcard $(srcdir)$(dir)/$(file)))))))

alldep = $(foreach file,$(allsrc), \
		 $(foreach dir,$(alldir),$(subst $(srcdir),$(objdir), \
		 $(firstword $(subst .c,.d,$(wildcard $(srcdir)$(dir)/$(file)))))))


#声明虚拟目标
.PHONY:	all init clean

#定义虚拟目标
ifeq ($(MAKELEVEL), 0)
all: init $(autdep)
	@echo $(MAKELEVEL) make done.
	@$(MAKE) all
else
all: $(autobj) $(target)
	@echo $(MAKELEVEL) make done.
endif

init:
	@mkdir -p $(foreach dir, $(alldir),$(objdir)$(dir))
	
clean:
	@rm -rf $(objdir) $(target)
	@echo clean done.
	
#生成d文件
%.d: %.c
	@echo $(MAKELEVEL) Generating depend file for $<...
	@$(CC) -MM -MT "$(subst $(srcdir),$(objdir),$(<D))/$(*F).o $(subst $(srcdir),$(objdir),$(<D))/$(@F)" -x c++ $(CXXFLAGS) $< >$(subst $(srcdir),$(objdir),$(<D))/$(@F)

ifeq ($(MAKELEVEL), 1)
%.o:
	@echo $(MAKELEVEL) Compiling $<...
	@$(CC) $(CFLAGS) -c $< -o $(subst $(srcdir),$(objdir),$(<D))/$(@F)
else
%.o: %.c
	@echo $(MAKELEVEL) Compiling $<...
	@$(CC) $(CXXFLAGS) -c $< -o $@
endif


ifeq ($(MAKELEVEL), 1)
include	$(alldep)

$(target): $(allobj)
	@echo Linking executable... $(target)
	@$(LD) $(LDFLAGS) -o $@ $^ $(inclib)
endif



Altium Designer精简版
Thu, 16 Feb 2017 11:55:49 +0000
AltiumDesigner是使用非常广泛的原理图/PCB设计工具，它还支持VHDL等其它EDA设计功能。
虽然现在的工作不是画PCB，但偶尔也会DIY一下，自娱自乐。主要工具就是AD系列的多个版本。
对于我而言，我只使用原理图和PCB设计，其它功能都用不上，而它的安装后体积竟然有3GB以上了，实在是太臃肿了！
这个软件的功能大多数是以组件的形式放在system目录下，因此可以进行适当的精简，减少软件的体积。
先放上我的精减版成品：
1. Altium Designer 6.9(build 6.9.0.12759)
压缩包25MB，解压后110MB，极度精简，只保留最基本的原理图和PCB设计，不含元件库，适合像我这样只做一些简单PCB的用户使用。
百度网盘：http://pan.baidu.com/s/1hsFnGIo
2.Altium Designer Summer 09(build9.3.1.19182)
压缩包120MB左右，解压后390MB左右，保留比较完善的原理图和PCB设计功能，支持DWG的导入和导出，但不含任何元件库。
百度网盘：http://pan.baidu.com/s/1skYXS1v
3.Altium Designer Summer 09(build9.4.0.20159)（ 推荐 ）
压缩包67MB，解压后400MB，去除了仿真，VHDL，软件编程等功能，保留比较完善的原理图和PCB设计功能；
支持导入其它文件格式和导出功能，不含元件库；
精简了菜单，修改了几条显示不准确的中文菜单。
百度网盘：http://pan.baidu.com/s/1kVNpker
版本说明
1. Protel 99SE
非常古老而经典的版本，在大学时期入门所使用的版本，运行非常流畅，基本功能都有，但总是经常崩溃，对中文支持非常不好。
2. DXP2004
后来发现了这个新版本，在XP系统下运行非常流畅，稳定，对中文支持也非常好，自带中文菜单。
当时非常喜欢这个版本，使用了很长时间，后来装上win7之后就GG了；
这个版本在win7以上系统问题很多，比如不能使用打印功能，必定崩溃……
3. AltiumDesigner6
为了在win7上画PCB，又找到了升级版本，简称AD6，最新版本号是AD6.9，界面与DXP2004类似。
在win7上运行，也很稳定，流畅。也是一个非常好用的经典版本！

AltiumDesigner Summer 08（内部版本号是7.0 ）

只 试用了一天时间，功能上也没有什么明显感觉， 据说 BUG很多，后来就没有研究了。
5.AltiumDesigner Winter 09（内部版本号是8.0）
这个版本，感觉比起AD6.9，明显卡顿了，启动也变慢了，用了一段时间后，感觉不够流畅，
功能上好像没有太明显的差异，还是继续使用AD6.9吧.
6.AltiumDesigner Summer 09 （内部版本号是9.0 ）
身边的朋友，大多数都在用这个版本，所以我也仔细地与AD6做了下对比。
和上一版本一样，卡顿，在低配机器上始终不如AD6流畅；
在原理图界面，双击一个元件，弹出属性菜单，明显有延迟，而AD6则快速很多，安装的元件库比较多时，卡顿更明显；
在库里面查找封装的时候，点击“Find”按钮，要卡很久很久才能弹出搜索窗口，但是搜索的速度比AD6要快不少，
我认为是在搜索的时候，软件会读取所有的库文件，建立一些索引，用来加快搜索速度，但第1次打开搜索对话框的时候就要卡死很长时间；
AD6在搜索的时候，没有索引，搜索速度要慢不少。
优点：这个新版本的PCB布线更加智能了，自动布线速度更快了，多线走也可以自动识别终点，布线的推挤功能感觉很好用！
7.AltiumDesigner 10
这个版本对界面做了调整，好多对话框在我的1366*768的分辨率下，根本显示不全，因为对话框上面增加了一个cloud的云选项。。。
DXP主菜单像Windows的开始菜单一样了，本人不太喜欢这种风格，界面越华丽，越占用资源，电脑越卡顿.
8.最近几年AD的更新速度非常快，10以后的版本开始向.NET平台转移了，安装包越来越庞大，越来越不喜欢它了！目前保留AD6.9和AD9.4两个版本就够用了。


STM32F429的LTDC和DMA2D
Thu, 29 Dec 2016 10:53:43 +0000
在阅读了STM32F429的手册之后，对LTDC与DMA2D有了一点认识，赶紧写下来做为笔记保存下来。
STM32F429与之前的系列强大之处就在于增加了LTDC个功能，从手册上看STM32F429的LTDC可以用于驱动1024x768分辨率的LCD屏幕。
LTDC其实就是TFT LCD控制器的意思，在arm9/arm11/cortex-A系列CPU当中，这个是必须有的外设，在小型单片机中，有这个功能的不多。
LCD控制器的功能就是生成LCD像素时钟，将GRAM中的数据搬运到LCD屏幕上去显示。
在一般的小型LCD模块一般都集成了一个LCD控制器，如常用的ili9320/ili9325等型号，这些LCD模块同时还集成了几百KB大小的RAM，用于显示；
这种方案，不需要占用单片机的RAM就可以稳定地驱动LCD显示图像，一般地MCU先通过8080接口或SPI向控制器发送命令，配置LCD参数，
然后向集成的RAM中写入数据就可以显示，是低成本项目的首选方案。
而STM32F429自带的LTDC也是LCD控制器，与ili9320相比，支持的分辨率更高，功能更多，但是LTDC只负责产生LCD需要的时序，并没有集成RAM，
如640x480x16bpp的屏幕，需要600KB的RAM，在单片机中600KB的内存，已经是天文数字了，所以需要外扩一片SDRAM来充当GRAM。
那么在使用LTDC的时候，首先要配置LCD的时序，然后要设置GRAM的地址（这里GRAM的地址就是外扩的SDRAM的地址），最后开启LTDC，可以在LCD_CLK引脚测量到有稳定的频率输出，应该就差不多了；配置好LTDC之后，硬件会自动将GRAM中的内容搬运到LCD屏幕上，只要改变GRAM中的数据就可以改变显示内容。
另外要说的是这个LTDC支持2个图层和1个背景图层，一般情况下用一个图层显示就可以了；这2个图层可以单独设置显示区域和GRAM地址，并且同时开启时，硬件自动将2个图层的显示内容进行混合，混合顺序是：图层2 -> 图层1 -> 背景色，图层2位于最顶层，至于怎么利用这两个图层实现特殊的功能，就仁者见仁，智者见智了。
DMA2D则是一个生活在GRAM世界中的一个搬运工，往你指定的内存地址中制造一个矩形，或者把一个矩形数据从源RAM复制到目的RAM，并且完全由硬件实现。
贴一个LTDC的初始化参考例程：
#include "stm32f4xx.h"
#include "gpio.h"
#include "ltdc.h"

#define HBP		8
#define VBP		4
#define HSW		1
#define VSW		1
#define HFP		30
#define VFP		1
#define WIDTH 	240
#define HEIGHT	320

#define FRAMEBUFFER	0xD0000000

static void ltdc_gpio_init(void)
{
	gpio_open(PA, 3, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PA, 4, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PA, 6, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PA,11, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PA,12, GPIO_MODE_AF, GPIO_AF_LTDC);
	
	gpio_open(PB, 0, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PB, 1, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PB, 8, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PB, 9, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PB,10, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PB,11, GPIO_MODE_AF, GPIO_AF_LTDC);
	
	gpio_open(PC, 6, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PC, 7, GPIO_MODE_AF, GPIO_AF_LTDC);
	
	gpio_open(PD, 3, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PD, 6, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PF,10, GPIO_MODE_AF, GPIO_AF_LTDC);
	
	gpio_open(PG, 6, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PG, 7, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PG,10, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PG,11, GPIO_MODE_AF, GPIO_AF_LTDC);
	gpio_open(PG,12, GPIO_MODE_AF, GPIO_AF_LTDC);
}

static void ltdc_clock_init(void)
{
    LTDC_InitTypeDef ltdc;
    ltdc.LTDC_HSPolarity = LTDC_HSPolarity_AL;
    ltdc.LTDC_VSPolarity = LTDC_VSPolarity_AL;
    ltdc.LTDC_DEPolarity = LTDC_DEPolarity_AL;
    ltdc.LTDC_PCPolarity = LTDC_PCPolarity_IPC;
    ltdc.LTDC_HorizontalSync       = HSW-1;
    ltdc.LTDC_VerticalSync         = VSW-1;                //垂直同步宽度
    ltdc.LTDC_AccumulatedHBP       = HSW+HBP-1;            //水平同步后沿宽度
    ltdc.LTDC_AccumulatedVBP       = VSW+VBP-1;            //垂直同步后沿高度
    ltdc.LTDC_AccumulatedActiveW   = HSW+HBP+WIDTH-1;      //有效宽度
    ltdc.LTDC_AccumulatedActiveH   = VSW+VBP+HEIGHT-1;     //有效高度
    ltdc.LTDC_TotalWidth           = HSW+HBP+WIDTH+HFP-1;  //总宽度
    ltdc.LTDC_TotalHeigh           = VSW+VBP+HEIGHT+VFP-1; //总高度
    ltdc.LTDC_BackgroundRedValue   = 0;
    ltdc.LTDC_BackgroundGreenValue = 0;
    ltdc.LTDC_BackgroundBlueValue  = 0;
	
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_LTDC,ENABLE);
    RCC_PLLSAIConfig(256, 2, 4);
    RCC_PLLSAICmd(ENABLE);
    while(RCC_GetFlagStatus(RCC_FLAG_PLLSAIRDY)==RESET);
    RCC_LTDCCLKDivConfig(RCC_PLLSAIDivR_Div8);
    LTDC_Init(<dc);
    LTDC_Cmd(ENABLE);
}

static void ltdc_layer_init(void)
{
	LTDC_Layer_InitTypeDef layer;
	layer.LTDC_HorizontalStart  = HBP+1;
	layer.LTDC_HorizontalStop   = WIDTH+HBP;
	layer.LTDC_VerticalStart    = VBP+1;
	layer.LTDC_VerticalStop     = HEIGHT+VBP;
	layer.LTDC_PixelFormat      = LTDC_Pixelformat_RGB565;
	layer.LTDC_ConstantAlpha    = 255;
	layer.LTDC_BlendingFactor_1 = LTDC_BlendingFactor1_PAxCA;
	layer.LTDC_BlendingFactor_2 = LTDC_BlendingFactor2_PAxCA;
	layer.LTDC_CFBStartAdress   = FRAMEBUFFER;
	layer.LTDC_CFBLineLength    = (WIDTH * 2)+3;
	layer.LTDC_CFBLineNumber    = HEIGHT;
	layer.LTDC_CFBPitch         = WIDTH * 2;
	layer.LTDC_DefaultColorRed  = 0;
	layer.LTDC_DefaultColorGreen= 0;
	layer.LTDC_DefaultColorBlue = 0;
	layer.LTDC_DefaultColorAlpha= 0;
	LTDC_LayerInit(LTDC_Layer1, &layer);
	LTDC_ReloadConfig(LTDC_IMReload);
	LTDC_LayerCmd(LTDC_Layer1, ENABLE);
	LTDC_ReloadConfig(LTDC_IMReload);
}

void ltdc_init(void)
{
	ltdc_gpio_init();
	ltdc_clock_init();
	ltdc_layer_init();
}



微软符号服务器使用方法
Fri, 18 Nov 2016 11:39:04 +0000
微软提供系统文件的调试符号文件，需要另行下载。
有了这些符号文件，在调试程序的时候，就能看到user32.dll,gdi32.dll等一系列文件的函数名称，
否则就显示user32.dll.0x67003246这样的地址，
以前的服务器地址：h ttp://msdl.microsoft.com/download/symbols
使用起来太慢了，Windows7以后的系统，提供全部符号文件打包下载：
下载地址在这里： https://developer.microsoft.com/zh-cn/windows/hardware/download-symbols
安装包300MB左右，安装后1GB以上，包括非常多的pdb文件！慢慢用吧！
等等。。。
使用方法：
打开VS2003以上的版本，在调试程序的时候，点击“模块”窗口，可以依次点击模块，右键，加载符号.
还可以直接把同名的pdb文件，放到dll相同的目录，Visual Studio就会自动加载.


通用点阵字库生成工具
Wed, 16 Nov 2016 16:55:45 +0000
虽然点阵提取工具，网上有很多了，但是找来找去，没找到我满意的工具，于是自己写了一个小工具。
点阵字体，在嵌入式GUI开发中，用得也是非常频繁的。
主要有两种使用场景：
1.生成某种编码的全部点阵，以BIN的形式放在FLASH中加载。
2.生成部份文字的点阵，以C文件的方式，写在代码里。
本工具的特点：
1.完全免费，不用到处找破解工具;
2.通用性好，支持任意编码，任意语言，可以自定义编码;
3.可以生成BIN和C文件;
4.可以使用WINDOWS全部字体;
5.使用方便，界面整洁;
界面效果图：

作者：星沉地动
//————————————————————————————————————————-
2017.09.02 (V1.1)
添加高位在前和低位在前的选项;
调整预览界面;
下载地址1：http://446252221.ys168.com/  (我的工具/通用点阵提取工具V1.1.zip 247KB)
下载地址2：https://pan.baidu.com/s/1kVBUGbt
//————————————————————————————————————————-
2017.09.15
公开此工具源代码。
源码地址： https://gitee.com/kerndev/FontMaker
//————————————————————————————————————————
2017.10.12(V1.1.2)
优化输出C文件数据格式;
下载地址1：http://446252221.ys168.com/  (我的工具/通用点阵提取工具-V1.1.2.zip 247KB)
下载地址2： https://pan.baidu.com/s/1geZ51rt
//————————————————————————————————————————
2018.07.31(V1.2.0)
支持生成非等宽字库。
下载地址： https://gitee.com/kerndev/FontMaker
//————————————————————————————————————————
2020.10.11(V1.3.0)
1.自定义码表添加去重功能;
2.输出CPP文件添加码表和字符计数;
3.更新GBK码表文件;
下载地址： https://gitee.com/kerndev/FontMaker
常见问题：
1.如何使用其它标准字符集？
在软件目录下有一个"charset"文件夹，程序启动的时候会扫描该文件夹下面的*.cst文件，并加入标准字库列表中；
cst文件就是码表文件，每个CST文件代表一种字符编码表，CST文件的数据格式为字符集中所有字符的UNICODE编码，2字节为一个单位，低字节在前。
该文件夹下面有一个“charset.exe”的程序，可以方便地生成大多数标准码表.
2.字符集中的“用户定义”是什么意思？
使用非标准字符集的使用可以使用自定义码表，比如简体中文的编码是GB2312，有6000多文字，但如果实际项目中你只想要“中华人民共和国”这7个汉字，
就可以在输入框中输入你需要的文字，生成一个特殊应用的字库，当然这个字库中的文字的排列顺序与你输入的顺序保持一致。
3.如何使用生成的BIN文件？
本工具生成的BIN数据格式为最常用的数据格式，一般情况下兼容其它字库文件；
对于水平扫描方式，8bit对齐格式，比如12x12像素的字库，每一行有12个点，但是会占用16bit即2个字节来表示；
那么一个文字占用2x12=24字节，读取BIN的时候以24字节为单位读取即可；
4.生成BIN文件与生成C文件有什么区别？
BIN文件一般用在通过文件读取字库，C文件是嵌入到代码里的数据。
5.为什么有很多字体的中文文字看上去是一样的？
这是因为Windows自带的字体，大多数都不是中文字体，
当显示中文的时候，系统会自动映射到默认的中文字体来显示，比如“宋体”，
宋体是使用点阵最清晰，最常规的字体，推荐使用宋体来做中文字库。


[代码片段]提升Win32进程权限
Mon, 31 Oct 2016 13:48:30 +0000
//提高进程权限
BOOL SelfPrivilegeUp(void)
{
	BOOL   ret;
	HANDLE hToken;
	LUID luid;
	TOKEN_PRIVILEGES tp;

	ret = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
	if(!ret)
	{
		return FALSE;
	}

	ret = LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid);
	if(!ret)
	{
		CloseHandle(hToken);
		return FALSE;
	}
	tp.PrivilegeCount = 1;
	tp.Privileges[0].Luid = luid;
	tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
	ret = AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
	if(!ret)
	{
		CloseHandle(hToken);
		return FALSE;
	}
	CloseHandle(hToken);
	return TRUE;
}
提权之后，可以读写其它进程。


某流氓安装程序的数据包(.data后缀)解压工具
Fri, 28 Oct 2016 11:44:54 +0000
在网上下载了一个NES小游戏的合集，本来应该是一个压缩包，里面包含N个.nes文件就OK了，但是解压发现竟然还要安装！
安装你大爷啊，这种文件还要安装？
一看这个安装程序的图标就不是什么好东西，不用想也知道安装后，肯定会自带一堆乱七八糟的软件。
目录下有一个20多MB的*.data文件，那所谓的安装程序，也就是把这个文件解压吧。
用WinHEX看了一下文件内容，不是什么常规的zip,rar,7z等文件格式，是一种自定义的文件结构。
作为一名程序猿！能被这种安装程序坑吗？
果断IDA走起，分析一下解压思路。。。。。。
N个小时以后，找到了关键点。
嗯，是一个lzma压缩的数据文件。
自己动手，写一个干净的解压程序吧！万一以后再次遇到这种文件，就有现成的工具可以用了。
从这个文件里可以找到一些网址：貌似是叫快猴的网站提供的。
放在这里，顺便方便网友使用。
百度网盘：https://pan.baidu.com/s/1skHqZGp


解决笔记本光驱位硬盘休眠卡顿问题
Fri, 28 Oct 2016 10:51:30 +0000
买了固态硬盘，把机械硬盘放到了光驱位，用了一段时间发现机械硬盘总是不定时的卡顿，卡顿，卡顿……
查了些资料，原因是因为这个硬盘在一段时间未使用，会自动休眠，应该是为了省电吧，马达停止转动了！
当要再次访问硬盘时，硬盘马达要重启启动，需要花时间，导致卡顿！
这个功能叫做APM(Advanced Power Management 高级电源管理)，可以使用CrystalDiskInfo这个软件，手动关闭APM功能，达到效果。
当然，这里是CSDN，如果只是告诉你怎么用这个软件，那就没意思了，现在重点开始！
APM这个功能，每次开机都会重置，那么每次开机都要用CrystalDiskInfo设置一次APM，这不是很麻烦吗？
作为一个程序猿，怎么能忍！必须要搞一个开机自动关闭APM的方法啊，网上找了半天，没有这样的工具，于是自己动手吧。
令人兴奋的是CrystalDiskInfo 是一个开源软件，基于MIT协议开放源代码，非常感谢CrystalDiskInfo的作者！
阅读了CrystalDiskInfo源码之后，终于找到了关闭APM的方法，写了一个小工具，开机运行就能关闭硬盘APM啦！
目前这个小工具只考虑SATA硬盘的情况，不一定保证兼容所有硬盘，因此大家请自测。
现送上这个小工具的BIN文件：http://pan.baidu.com/s/1pLFieAf
开源大法好：http://download.csdn.net/detail/qq446252221/9666482
2017.7.27更新：
上个版本这个工具关闭窗口存在无法关闭的问题，现在已经修复了。
下载地址：http://pan.baidu.com/s/1pLFieAf


Keil 5使用JLink连接正在运行的CPU
Thu, 08 Sep 2016 09:46:27 +0000
环境:
目标CPU:STM32F429
连接工具:JLink V9
连接方式:SWO
调试工具:Keil MDK 5.20
使用场景:
目标板正在运行,但是出BUG了,需要调试,而当前又没有在线debug,
于是就需要用调试器在不复位CPU的前提下附着到正在运行的板子上.
使用步骤:
1.首先确认你有与当前CPU运行的程序一样的源码,编译时生成了调试信息(Debug Information).
2.修改debug设置,去掉"Load Appcalition at Startup"的勾选.
3.检查JLink的设置,“Connect:Normal"表示正常连接,不复位,“Reset:Normal” 表示连接后不复位,不勾选"Reset after Conn”,不勾选"Download to Flash"
4.将JLink连接至目标板的调试接口.
5.点击Keil中的调试按钮,启动调试.前面的设置正确的话CPU会停止运行,但不会复位,此时只能看汇编指令,没有C源码.
6.在Command窗口输入命令:LOAD %L INCREMENTAL(这条命令是加载当前项目的输出文件,读取调试信息,这样就可以看到C源码了).
7.现在就和正常调试一样了.
备注:
第6步还有另一种方式自动加载,在"Debug"设置对话框里填入一个"Initialization File:",
在该文件里面写上"LOAD %L INCREMENTAL",就可以了,点击"开始调试"后,Keil会自动执行该命令.
参考图片:




非常简洁易用的嵌入式RTOS内核----KLite
Tue, 21 Jun 2016 10:14:46 +0000
KLite是一个为ARM Cortex-M微控制器设计的 微内核 ,设计思想是"简洁易用".
它最大的特性在于简洁易用,可能是目前为止最简单易用的嵌入式 操作系统 内核.
简洁的API风格,简洁的调用方式,简单的移植方法,大大降低学习难度,
即使是初学者也能很容易开始进入多线程的开发方式.
KLite的特性：
1.基于Cortex-M设计开发，免移植即可在CM0,CM3,CM4的MCU上运行；
2.使用方便，免裁剪，预编译库只有3个文件，直接包含进工程即可；
3.API风格简洁，命名规范，简洁易懂；
4.支持内存管理，自动申请线程堆栈，拒绝繁琐；
5.线程数量限制仅因内存限制；
6.线程支持256级优先级抢占，相同优先级采用FCFS调度 算法 ；
7.支持最核心的线程同步对象:互斥锁,信号量.
8. 很容易扩展出其它功能如:消息队列,邮箱等功能.
开源地址:
http://www.oschina.net/p/klite
作者在git仓库准备了一份demo工程
http://git.oschina.net/kerndev/klite-demo


EPT分区表
Wed, 18 May 2016 11:59:58 +0000
对，你没有看错是EPT，不是GPT，也不是MBR分区表！
什么是EPT，目前根本没有EPT分区表，EPT是我自定义的一种分区表格式。
EPT是介于MBR和GPT之间的一种分区表格式，比MBR支持更多的分区，比GPT更少的开销。
一个MBR只能记录4个分区，局限比较大；GPT设计得“过于”复杂，在单片机等小系统中使用不太方便，特别是GUID的引入，一个表项数据太长了。
于是我在嵌入式小系统项目中就自定义了一种分区格式，叫EPT！
EPT(E=Embedded P=Partition T=Table)只是我个人定义的规范，写在这里也是为了方便我以后查询，没有别的目的，各位看官不要深扒。
EPT储存方式：
从磁盘(或FLASH)的第1个扇区做为主EPT数据储存区，第2个扇区做为备份EPT。
EPT数据结构：
EPT包括表头与表项，每项均占32字节，目的是为了数据对齐。
表头储存在0－31字节，32字节以后为表项，每个表项均占32字节，且连续储存。
字节顺序为小端格式，如32位字0x12345678，按字节储存为：78 56 34 12。
EPT表头结构:
struct ept_hdr
{
uint32_t magic;//标记=0x00545045，“EPT\0”
uint32_t blksize; //扇区/块大小
uint32_t crc32;//所有表项的CRC32校验，确保完整性，CRC-32-IEEE 802.3标准
uint8_t  revd[20]; //保留字节
};
EPT表项结构:
struct ept_item
{
char     name[16]; //分区名称
uint32_t start;  //起始扇区
uint32_t size;  //分区大小
uint8_t  revd[8]; //保留字节，以后可以用作分区类型标识
};
示例:

示例说明：
扇区大小:512字节
名称       起始扇区 扇区数量 起始地址   分区大小
boot        0x0100   0x0800   0x020000  0x100000 1MB
logo        0x0900   0x0800   0x120000  0x100000 1MB
kernel     0x1100   0x4000   0x220000  0x800000 8MB
ramdisk  0x5100   0x4000   0xA20000  0x800000 8MB


CRC32校验算法C语言版(查表法)
Mon, 16 May 2016 17:20:27 +0000
最近用到CRC校验算法，就找了些资料，学习了一下，网上关于CRC32的资料也多，但感觉不是很完整，或者太高深。
CRC算法查表法很常见，但表是怎么来的，有些资料说得不很清楚。
我来说一下我的看法：
1.CRC校验变化太多，有CRC4/5/6/7/8/16/32，每一种的多项式也有很多种变化，并不是一成不变的；
2.输入输出方式也有区别，有一些初始值是0，有一些初始值是0xFFFFFFFF，有一些直接返回，有一些异或返回。
因此，CRC校验很难用一个代码兼容全部，只能根据项目需要修改相关参数了。
计算方法：
1.先要知道多项式是什么样子，以这个IEEE802.3标准CRC32多项式为例： x ³²+ x ²⁶+ x ²³+ x ²²+ x ¹⁶+ x ¹²+ x ¹¹+ x ¹⁰+ x ⁸+ x ⁷+ x ⁵+ x ⁴+ x ²+ x +
1
2.转换成一个值（这个值的命名我不知道啊）
x32  则对应32bit = 1, x26 则对应26bit=1，得出一个值：(1<<32)|(1<<26)|(1<<23)|(1<<22)|...|(1<<1)|(1)=0x104C11DB7，对于CRC32取低32位，则＝0x4C11DB7
3.用这个值通过一定方法生成长度为256的码表，对于CRC32表内每个元素都为32bit.
4.用一定的方法查表得出CRC32值。
好了，可以贴代码了:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>


static uint32_t table[256];


//位逆转
static uint32_t bitrev(uint32_t input, int bw)
{
    int i;
    uint32_t var;
    var = 0;
    for(i=0; i<bw; i++)
    {
        if(input & 0x01)
        {
            var |= 1<<(bw - 1 - i);
        }
        input >>= 1;
    }
    return var;
}


//码表生成
void crc32_init(uint32_t poly)
{
    int i;
    int j;
    uint32_t c;


    poly = bitrev(poly, 32);
    for(i=0; i<256; i++)
    {
        c = i;
        for (j=0; j<8; j++)
        {
            c = (c & 1) ? (poly ^ (c >> 1)) : (c >> 1);
        }
        table[i] = c;
    }
}


//计算CRC
uint32_t crc32(uint32_t crc, void* input, int len)
{
    int i;
    uint8_t index;
    uint8_t *p;
    p = (uint8_t*)input;
    for(i=0; i<len; i++)
    {
        index = (*p ^ crc);
        crc = (crc >> 8) ^ table[index];
        p++;
    }
    return crc;
}


//测试用例
void main(void)
{
    uint32_t crc;
    crc32_init(0x4C11DB7);
    crc = crc32(0xFFFFFFFF, "1234567890", 10);
    printf("CRC32 = 0x%08X\n", crc ^ 0xFFFFFFFF);
    system("pause");
}
2017.11.07更新代码: 由于原代码使用unsigned long类型,在64位环境下是64位数据类型,会出现计算结果不正确,因此将其替换为uint32_t类型;


简化版的SHA1算法C语言版
Mon, 16 May 2016 16:41:38 +0000
最近用到了一些常规散列算法，学习一下SHA算法，网上SHA1介绍很多，也有实例，但代码风格似乎不符合我的审美。
经过学习验证，编写了一个简化版的SHA1算法，为什么叫简化版呢？
因为这个算法只能处理56字节以内的数据，大于等于56字节的情况要分组计算。
分组补位有点麻烦，怎么合理分组，还有待思考。
先贴出简化版的代码吧。
/*
* SHA1散列算法
* <kerndev@foxmail.com>
* 参考:http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
*/
#include <stdio.h>
#include <string.h>
#include "sha1.h"

#define S(x,n)	(((x)<<n)|(x)>>(32-n))	//SHA定义S函数为循环左移

static unsigned long h[5];
static unsigned long m[16];
static unsigned long w[80];

//补位(余数=448)+补长度(64位)=512位M
static void sha1_pad(unsigned char *input, int len)
{
	int i;
	int n;

	for(i=0;i<16;i++)
	{
		m[i] = 0;
	}

	for(i=0;i<len;i++)
	{
		n = 24-((i&0x03)<<3);
		m[i/4] |= input[i]<<n;
	}
	n = 24-((i&0x03)<<3);
	m[i/4] |= 0x80<<n;
	m[15] = len*8;
}

//由512位M生成80字W
static void sha1_prepare(void)
{
	int i;
	for(i=0;i<16;i++)
	{
		w[i]=m[i];
	}
	for(i=16;i<80;i++)
	{
		w[i]=w[i-16]^w[i-14]^w[i-8]^w[i-3];
		w[i]=S(w[i],1);
	}
}

//由80字W计算sha1
static void sha1_calc(void)
{
	int i;
	unsigned long a,b,c,d,e,f,k;
	unsigned long temp;
	
	h[0]=0x67452301;
	h[1]=0xEFCDAB89;
	h[2]=0x98BADCFE;
	h[3]=0x10325476;
	h[4]=0xC3D2E1F0;
	
	a = h[0];
	b = h[1];
	c = h[2];
	d = h[3];
	e = h[4];
	for(i=0;i<80;i++)
	{
		switch(i/20)
		{
		case 0:
			k=0x5A827999;
			f=(b&c)|(~b&d);
			break;
		case 1:
			k=0x6ED9EBA1;
			f=b^c^d;
			break;
		case 2:
			k=0x8F1BBCDC;
			f=(b&c)|(b&d)|(c&d);
			break;
		case 3:
			k=0xCA62C1D6;
			f=b^c^d;
			break;
		}
		temp=S(a,5)+f+e+w[i]+k;
		e=d;
		d=c;
		c=S(b,30);
		b=a;
		a=temp;
	}
	h[0]+=a;
	h[1]+=b;
	h[2]+=c;
	h[3]+=d;
	h[4]+=e;
}

//SHA1算法接口
//input:待校验的数据
//len:数据长度(小于56字节)
unsigned long* sha1(void* input, int len)
{
	sha1_pad(input,len);
	sha1_prepare();
	sha1_calc();
	return h;
}
测试用例：


手动安装Keil5（制作绿色版/精简版MDK Keil）
Thu, 12 May 2016 18:32:56 +0000
经常使用ARM Keil5；
而它更新也很频繁；
安装包也非常大；
每次安装还自动安装ULink驱动，不能忍了，必须要动刀子了。
手动制作Keil的绿色版，或者说手动安装Keil:
首先要下载好MDK518.EXE，400多MB。这个安装包其实就是一个压缩包，可以直接解压。
原理就不多说了，直接说步骤吧：
1.解压它，得到"ARM"和"UV4"两个文件夹，和四个小文件。
2.保留两个文件夹和"SETUP.INI",把SETUP.INI改名为TOOLS.INI
3.打开TOOLS.INI，
删除[UV2]以前的全部内容，
修改[UV2]下面的RTEPATH=“你当前目录\ARM\PACK”，
修改[ARM]下面的PATH=“你当前目录\ARM”,
修改[ARMADS]下面的PATH=“你当前目录\ARM”
修改[ARMADS]下面的PATH1=".\ARMCC\bin"
4.现在你可以去UV4文件夹下面双击UV4.EXE，启动Keil了，实践证明Keil不能放到中文路径下，否则有问题。
以上1－4步骤就是手动安装过程，下面说说精简：
A.精简TOOLS.INI
在[ARM]和[ARMADS]下面的BOOK开头的都可以删除，这个是帮助内容，以TDRV开头的是UV4工程Debug选项下面的调试器选项，一般用JLink的话只保留Segger\JLTAgdi.dll和Segger\JL2CM3.dll，其它都可以删除，免得看到烦，如果你要用其它的，自行选择删除。
B.精简调试器
刚才在TOOLS.INI中删除的TDRVx内容所对应的文件都可以删除，什么Signum\SigUV3Arm.dll, NULink\Nu_Link.dll这些文件统统都删掉，看到讨厌。
C.精简其它文件
在UV4目录下UV4.cdb,uv4.chm,uv4jp.chm可以放心删除。
后缀为.SVCS的是版本控制功能选项，用不上的可以删除，删除了之后IDE界面的SVCS菜单就干净了。
在ARM\Pack目录下的文件也用不上，可以删除。
在ARM\Flash目录也可以删除。
在ARM\Utilities目录也可以删除。
在ARM\Startup目录也可以删除。
在ARM\Help目录也可以删除，这个文件夹太大了。
在ARM\ARMCC\lib\cpplib，如果不用C++开发，也可以删除
D.完了，这下Keil绿色精简版就做好了。一下就清爽了
附上一个编缉好的TOOLS.INI文件
[UV2]
ARMSEL=1
USERTE=1
RTEPATH="C:\Program Files\Keil\ARM\PACK"
TOOL_VARIANT=mdk_pro

[ARM]
PATH="C:\Program Files\Keil\ARM\"
LIC0=此处已删除

[ARMADS]
PATH="C:\Program Files\Keil\ARM\"
PATH1=".\ARMCC\bin\"
ARMCCPATH0="ARMCC" ("V5.06u1 (build 61)")
RTOS0=Dummy.DLL("Dummy")
CPUDLL0=SARM.DLL(TDRV0,TDRV4,TDRV5,TDRV8)                                                          # Drivers for ARM7/9 devices
CPUDLL1=SARMCM3.DLL(TDRV1,TDRV2,TDRV3,TDRV4,TDRV6,TDRV7,TDRV9,TDRV10,TDRV11,TDRV12,TDRV13,TDRV14)  # Drivers for Cortex-M devices
CPUDLL2=SARMCR4.DLL(TDRV6)                                                                         # Drivers for Cortex-R4 devices
TDRV0=Segger\JLTAgdi.dll("J-LINK / J-TRACE ARM")
TDRV1=Segger\JL2CM3.dll("J-LINK / J-TRACE Cortex")



发一个简洁实用的串口调试工具
Thu, 12 May 2016 17:56:37 +0000
网上的串口调试工具，已经很多啦，但是大多数长得都差不多，而且都有一些小广告在上面，总不完美，
因此本人编写了一个自认为比较体符合我需求的串口调试工具。
此工具基于Win32 SDK开发，无需MFC库，文件体积小，只有一个exe，界面纯净，没有多余的东西！
该有的功能都有，支持921600波特率！
当前版本：2.0.4

下载地址：
http://pan.baidu.com/s/1mhQNJGs


蓝牙手柄按键码
Tue, 16 Feb 2016 14:51:09 +0000
/*——————————————————————————
ZetaGC串口码与键码对应关系：
上     0x60 -> 0x26   

下     0x30 -> 0x28   | 此4键只能相邻按键组合按下
左     0x20 -> 0x25   |
右     0x10 -> 0x27   /
A      0x01 -> 0xC1   

AA     0x02 -> 0xC3   | 此4键可任意组合按下
B      0x04 -> 0xC2   |
BB     0x08 -> 0xC4   /
SELECT 0xE0 -> 0xC5   

START  0xE1 -> 0xC6   | 此3键不能与其他键同时按下
OK     0xE2 -> 0x0D   /
*/
/*——————————————————————————
PhoneJoy商业手柄键码定义：
压下   抬起
上     BA45   FA05
下     BD42   FD02
左     BB44   FB04
右     BC43   FC03
A      B649   F609
B      B54A   F50A
C      BE41   FE01
D      B748   F708
SELECT B34C   F30C
START  B44B   F40B
L      B847   F807
R      B946   F906
*/


在Keil环境下使用JLink实现printf输出重定向至debug窗口
Thu, 28 Jan 2016 22:06:46 +0000
在工程里面添加下列代码：
#include <stdio.h>

#define ITM_Port8(n)    (*((volatile unsigned char *)(0xE0000000+4*n)))
#define ITM_Port16(n)   (*((volatile unsigned short*)(0xE0000000+4*n)))
#define ITM_Port32(n)   (*((volatile unsigned long *)(0xE0000000+4*n)))
#define DEMCR           (*((volatile unsigned long *)(0xE000EDFC)))
#define TRCENA          0x01000000


//半主机模式必须定义这个
struct __FILE
{
    int handle;
};
FILE __stdout;
FILE __stdin;

int fputc(int ch, FILE *f)
{
    if (DEMCR & TRCENA)
    {
        while (ITM_Port32(0) == 0);

        ITM_Port8(0) = ch;
    }
    return(ch);
}
点击JLink的调试设置对话框，Trace页面，如下图设置即可：

原始文章：
http://www.keil.com/support/man/docs/jlink/jlink_trace_itm_viewer.htm


Keil 5中精简器件支持包,手动安装pack包
Wed, 20 Jan 2016 20:01:47 +0000
Keil MDK 5.0以后的版本都使用软件包的方式来支持你的MCU，比如STM32F103要下载STM32F10x_DFP.pack，
但是发现有一些设备提供的支持包竟然达到200MB以上，解压后1GB以上，简直不能忍，必须对它动刀子！
经过分析后，pack包其实就是一个标准的zip文件，可以直接解压，精简方法也很简单，这里有两种途径：
一，安装后精简
先正常安装xxxxx.pack，然后到Keil安装目录下找到Keil\ARM\Pack\Keil\xxxxxxxx_DFP\a.b.c，删除那些用不上的文件，但是要保留Keil真正使用的文件：
package.xml
Keil.xxxxx_DFP.pdsc
Flash/xxxxxxx.FLM (用于Keil直接加载程序到FLASH)
SVD/xxxxx.SVD
SVD/xxxxx.SFR (用于在线调试时，查看外设寄存器的值)
这几个文件其实非常小，只有几MB而已。
二，安装前精简
直接解压xxxx.pack，直接删除不需要的文件，然后重新用ZIP打包，再用PackInstaller.exe导入这个zip文件即可。
也可以手动安装这些文件，将解压后的文件按照原目录结构复制到Keil\ARM\Pack\Keil\xxxxxxxx_DFP\a.b.c目录，
其中xxxxxxx_DFP这个名字从Keil.xxxxx_DFP.pdsc里面找到name
a.b.c为版本号，也从Keil.xxxxx_DFP.pdsc里面找到
值得注意的是：直接解压xxxxx.pack文件，SVD目录下面只有SVD文件而没有SFR文件，需要手动生成，生成方法:
*SVDConv.exe  xxxxxx.svd –generate=sfr -o=Keil\ARM\Pack\Keil\xxxxxxxx_DFP\a.b.c\SVD*


自己动手制作纯净版的WinPE
Fri, 13 Nov 2015 12:42:40 +0000
WinPE作为系统维护工具，已经必不可少，WinPE有很多版本，官方介绍的WinPE版本如下：
WinPE1.0  基于WinXP
WinPE1.1 基于WinXP SP1
WinPE1.2 基于Win2003
WinPE1.5 基于WinXP SP2
WinPE1.6 基于Win2003 SP1
WinPE2.0 基于Win Vista
WinPE2.1 基于Win Vista SP1
WinPE2.2 基于Win Vista SP2
WinPE3.0 基于Win7
WinPE3.1 基于Win7 SP1
WinPE4.0 基于Win8
WinPE5.0 基于Win8.1
2016.5.12更新：我把做好的ISO文件也发上来共享，百度网盘： http://pan.baidu.com/s/1nuVIlip
基于Win7企业版 64位系统，支持UEFI启动，完全纯净。
不保证兼容性，请自测。
这么多年来都是用网上下载的PE系统，最近心血来潮想自己做一个，于是花了2个星期的时间做了一个纯净版的WinPE3.0。在此记录一下制作过程，以备以后查阅。
1.准备工作
下载原版系统镜像，提取boot.wim,install.wim，解压boot.wim的分卷1，这就是最基本WinPE环境，再解压install.wim，这个完整的Win7运行环境；新建工作目录BOOT，把Win7的文件拷贝进来，再把WinPE的文件合并并替换同名文件，这就得到一份超级完整的WinPE文件，有10GB以上，文件6万多个。
2.注册表合并
如果用win7的SOFTWARE用来启动WinPE，无法打开Explorer错误提示：因配置标识不正确，系统无法开始服务器。
如果用WinPE的SOFTWARE用来启动WinPE，无法启动Explorer
稳定的做法是以win7的SOFTWARE为模版，导入WinPE的SOFTWARE。
3.注册表修改
加载DEFAULT,SOFTWARE,SYSTEM，
删除所有 Interactive User
替换 *C:* , *D:* 为 *X:*
替换 *$windows.~bt* 为空字符
修改以下注册表项：
[HKEY_LOCAL_MACHINE__SYSTEM\Setup]
CmdLine=”pecmd.exe main %SystemRoot%\System32\PECMD.INI”
[HKEY_LOCAL_MACHINE__SOFTWARE\Microsoft\WindowsNT\CurrentVersion\Winlogon]
Shell=”explorer.exe”
通过以上操作就能启动这个完整的WinPE了，剩下的工作就是精简和优化了。（）
精简步骤省略，可以删除的文件。这是一个枯燥而又没什么技术含量的工作，从原版的6万多个文件，反复对比删除，测试，然后又添加，最后可以精简到1000个文件左右。除了文件，就是注册表的修改，注册表表项也达60多MB容量的纯文本，也是一项非常费时的工作！
在此列举我在这个过程中发现的问题，以及解决办法：
常见的问题总结：


windows系统MSDN下载地址
Fri, 06 Mar 2015 14:43:09 +0000
有时候要装一些系统，要到处找下载地址，现在我记在这里，方便我以后找到
Windows7 简体中文旗舰版（MSDN原版）
32位：
ed2k://|file|cn_windows_7_ultimate_x86_dvd_x15-65907.iso|2604238848|D6F139D7A45E81B76199DDCCDDC4B509|/
SHA1：B589336602E3B7E134E222ED47FC94938B04354F
64位：
ed2k://|file|cn_windows_7_ultimate_x64_dvd_x15-66043.iso|3341268992|7DD7FA757CE6D2DB78B6901F81A6907A|/
SHA1：4A98A2F1ED794425674D04A37B70B9763522B0D4
Windows 7 With SP1 简体中文旗舰版（MSDN原版）
32位：
ed2k://|file|cn_windows_7_ultimate_with_sp1_x86_dvd_u_677486.iso|2653276160|7503E4B9B8738DFCB95872445C72AEFB|/
SHA1:B92119F5B732ECE1C0850EDA30134536E18CCCE7 ISO/CRC:76101970
64位：
ed2k://|file|cn_windows_7_ultimate_with_sp1_x64_dvd_u_677408.iso|3420557312|B58548681854236C7939003B583A8078|/
SHA1: 2CE0B2DB34D76ED3F697CE148CB7594432405E23 ISO/CRC: 69F54CA4


编译mplayer for arm记录
Fri, 06 Mar 2015 11:33:36 +0000
mplayer( http://www.mplayerhq.hu/ )
当前版本：mplayer-export-2015-01-12（SVN-r37353-snapshot-4.9.2）
编译mplayer需要ffmpeg( http://ffmpeg.org/ )
当前版本：ffmpeg-2.5.4
之前在mplayer源码目录configure总是编译通不过，在编译到ffmpeg里面的vfp_fft.S的时候总报错，后来先在ffmpeg目录下make完成后，再返回mplayer目录make,就编译通过了
，具体运行效果还没有测试。先记录一下编译配置，方便以后修改查看
mplayer
./configure –host-cc=gcc –cc=arm-linux-gnueabi-gcc –as=arm-linux-gnueabi-as –ar=arm-linux-gnueabi-ar –target=arm-linux –enable-cross-compile –enable-armv6 –enable-armvfp –enable-alsa –enable-fbdev –disable-gui –disable-win32dll –disable-tv –disable-pvr –disable-v4l2 –disable-vcd –disable-dvb –disable-md5sum –disable-yuv4mpeg –disable-tga –disable-pnm –disable-dvdread –disable-dvdnav  –disable-mencoder –disable-live –disable-mad –disable-xanim –disable-real –disable-decoder=hevc –extra-ldflags=-L/home/arm/alsa-lib/lib –extra-cflags="-mcpu=arm1176jzf-s -I/home/arm/alsa-lib/include" –prefix=/home/arm/mplayer
ffmpeg:
./configure –prefix=/home/arm/mplayer –cross-prefix=arm-linux-gnueabi- –arch=arm –cpu=arm1176jzf-s –enable-cross-compile –target-os=linux –enable-armv6 –enable-vfp –disable-armv6t2 –disable-armv5te –disable-neon –disable-debug –disable-programs –disable-encoders –disable-decoder=hevc –disable-fft –disable-network –disable-doc


2阶节IIR算法C语言源码
Wed, 14 Jan 2015 10:52:22 +0000
纯C语言软件算法，没有做过多优化，只是实现了基本IIR算法
/******************************************************************************
* 二阶IIR滤波器单元,采用直接II型
* 由多个2阶节，可以组成更多高阶的滤波器
* 根据参数的不同，可以生成低通，高通，带通，带阻
******************************************************************************/
#include "iir.h"

//初始化IIR数据
void IIR_Init(IIR_Typedef *pIIR, IIR_COEF* pCoef)
{
	int i;
	for (i=0; i<3; i++)
	{
		pIIR->fCoefA[i] = pCoef->fCoefA[i];
		pIIR->fCoefB[i] = pCoef->fCoefB[i];
		pIIR->fTemp[i]  = 0;
	}
}

//复位历史值
void IIR_Reset(IIR_Typedef *pIIR)
{
	pIIR->fTemp[0] = 0;
	pIIR->fTemp[1] = 0;
	pIIR->fTemp[2] = 0;
}

//IIR滤波
float IIR_Filter(IIR_Typedef *pIIR, float fInput)
{
	float fOutput;
	//计算输入值
	pIIR->fTemp[0] = fInput;
	pIIR->fTemp[0] = pIIR->fTemp[0] - pIIR->fCoefA[1] * pIIR->fTemp[1];
	pIIR->fTemp[0] = pIIR->fTemp[0] - pIIR->fCoefA[2] * pIIR->fTemp[2];

	//计算输出值
	fOutput = 0;  
	fOutput = fOutput + pIIR->fCoefB[0] * pIIR->fTemp[0];  
	fOutput = fOutput + pIIR->fCoefB[1] * pIIR->fTemp[1]; 
	fOutput = fOutput + pIIR->fCoefB[2] * pIIR->fTemp[2]; 
	
	//移动历史值
	pIIR->fTemp[2] = pIIR->fTemp[1];  
	pIIR->fTemp[1] = pIIR->fTemp[0];

	return fOutput; 
}
头文件iir.h


编译ARM Linux GCC工具链
Wed, 14 Jan 2015 10:46:55 +0000
近日心血来潮想自己编译一次ARM-GCC工具链
于是上网找了找编译方法，并下载了源码，过程中出了很多错，但最终成功编译出了我想要的GCC，于是在此记录一下编译过程.
我的目标GCC版本：4.8.4
GNU编译工具链包括binutils, gcc, glibc
binutils:汇编器、连接器
gcc:预处理器、编译器
glibc: C语言库
编译arm-linux-gcc需要编译两次：
第一次是编译一个不带库的临时gcc，可以用来编译裸机程序如linux内核和u-boot等.
然后用第一次编译的gcc来编译目标平台的glibc(或者uclibc)
然后再进行第二次gcc编译.
准备以下源码：
binutils-2.25.tar.bz2
gcc-4.8.4.tar.bz2
glibc-2.21.tar.xz
gmp-5.1.3.tar.xz
linux-3.4.106.tar.xz
mpc-1.0.3.tar.gz
mpfr-3.1.2.tar.xz
编译顺序是这样的：
gmp -> mpfr -> mpc ->binutils -> gcc -> glibc -> binutils -> gcc
需要注意的是，最好在一个新的文件夹下面进行编译：
#tar -xf gcc-4.8.4.tar.bz2
#cd gcc-4.8.4
#mkdir build
#cd build
1.依次编译gmp,mpfr,mpc
#../configure–host=i686-linux-gnu –disable-shared
#make
#make install
说明：
可以使用../configure –help来查看有哪些参数可以设置
–prefix设置安装目录（默认是/usr/local/lib）
–host指定目标平台
–disable-shared不编译动态库
2.编译binutils
第一次编译的配置：
#../configure –disable-nls–disable-multilib –disable-shared –target=arm-none-linux-gnueabi–prefix=/home/toolchain/arm-none-linux-gcc
make
make install
3.编译gcc
#../configure –enable-targets=all–enable-languages=c –disable-checking –disable-shared –disable-threads–disable-multilib –disable-nls –disable-decimal-float –disable-libgomp–disable-libmudflap –disable-libssp –disable-bootstrap –disable-libquadmath–disable-libatomic –without-headers –with-newlib –host=i686-linux-gnu  –target=arm-none-linux-gnueabi–prefix=/home/toolchain/arm-none-linux-gnueabi
#make -j4
#make install
使用make -j4可以4线程编译，加快速度，我的机器上大约用了8分钟编译完成。


256点FFT函数
Mon, 10 Mar 2014 13:36:19 +0000
从网上找到的一段感觉比较好的FFT函数，可以直接使用，出处由于时间原因已经忘记了@@
//文件名：fft.c
#include "fft.h"

//128等分余弦表
static const double cosTable[] =
{
	1.0000,0.9997,0.9988,0.9973,0.9952,0.9925,0.9892,0.9853,
	0.9808,0.9757,0.9700,0.9638,0.9569,0.9495,0.9415,0.9330,
	0.9239,0.9142,0.9040,0.8932,0.8819,0.8701,0.8577,0.8449,
	0.8315,0.8176,0.8032,0.7883,0.7730,0.7572,0.7410,0.7242,
	0.7071,0.6895,0.6716,0.6532,0.6344,0.6152,0.5957,0.5758,
	0.5556,0.5350,0.5141,0.4929,0.4714,0.4496,0.4276,0.4052,
	0.3827,0.3599,0.3369,0.3137,0.2903,0.2667,0.2430,0.2191,
	0.1951,0.1710,0.1467,0.1224,0.0980,0.0736,0.0491,0.0245,
	-0.0000,-0.0245,-0.0491,-0.0736,-0.0980,-0.1224,-0.1467,-0.1710,
	-0.1951,-0.2191,-0.2430,-0.2667,-0.2903,-0.3137,-0.3369,-0.3599,
	-0.3827,-0.4052,-0.4276,-0.4496,-0.4714,-0.4929,-0.5141,-0.5350,
	-0.5556,-0.5758,-0.5957,-0.6152,-0.6344,-0.6532,-0.6716,-0.6895,
	-0.7071,-0.7242,-0.7410,-0.7572,-0.7730,-0.7883,-0.8032,-0.8176,
	-0.8315,-0.8449,-0.8577,-0.8701,-0.8819,-0.8932,-0.9040,-0.9142,
	-0.9239,-0.9330,-0.9415,-0.9495,-0.9569,-0.9638,-0.9700,-0.9757,
	-0.9808,-0.9853,-0.9892,-0.9925,-0.9952,-0.9973,-0.9988,-0.9997,
};

//128等分正弦表
static const double sinTable[] = 
{
	0.0000,0.0245,0.0491,0.0736,0.0980,0.1224,0.1467,0.1710,
	0.1951,0.2191,0.2430,0.2667,0.2903,0.3137,0.3369,0.3599,
	0.3827,0.4052,0.4276,0.4496,0.4714,0.4929,0.5141,0.5350,
	0.5556,0.5758,0.5957,0.6152,0.6344,0.6532,0.6716,0.6895,
	0.7071,0.7242,0.7410,0.7572,0.7730,0.7883,0.8032,0.8176,
	0.8315,0.8449,0.8577,0.8701,0.8819,0.8932,0.9040,0.9142,
	0.9239,0.9330,0.9415,0.9495,0.9569,0.9638,0.9700,0.9757,
	0.9808,0.9853,0.9892,0.9925,0.9952,0.9973,0.9988,0.9997,
	1.0000,0.9997,0.9988,0.9973,0.9952,0.9925,0.9892,0.9853,
	0.9808,0.9757,0.9700,0.9638,0.9569,0.9495,0.9415,0.9330,
	0.9239,0.9142,0.9040,0.8932,0.8819,0.8701,0.8577,0.8449,
	0.8315,0.8176,0.8032,0.7883,0.7730,0.7572,0.7410,0.7242,
	0.7071,0.6895,0.6716,0.6532,0.6344,0.6152,0.5957,0.5758,
	0.5556,0.5350,0.5141,0.4929,0.4714,0.4496,0.4276,0.4052,
	0.3827,0.3599,0.3369,0.3137,0.2903,0.2667,0.2430,0.2191,
	0.1951,0.1710,0.1467,0.1224,0.0980,0.0736,0.0491,0.0245,
};

//快速求平方根
float sqrt_fast(float x)
{
	long  lx;
	float temp;
	float xhalf = x * 0.5f;
	lx = *((long*)&x);
	lx = 0x5F375A86 - (lx>>1);
	temp = *((float*)&lx);
	temp = temp*(1.5f - xhalf*temp*temp);
	temp = temp*(1.5f - xhalf*temp*temp);
	temp = temp*(1.5f - xhalf*temp*temp);
	return temp * x;
}

//8bit位反转
unsigned char bitrev(unsigned char i)
{
	unsigned char r=0;
	r |= (i>>0)&0x01;
	r<<= 1;
	r |= (i>>1)&0x01;
	r<<= 1;
	r |= (i>>2)&0x01;
	r<<= 1;
	r |= (i>>3)&0x01;
	r<<= 1;
	r |= (i>>4)&0x01;
	r<<= 1;
	r |= (i>>5)&0x01;
	r<<= 1;
	r |= (i>>6)&0x01;
	r<<= 1;
	r |= (i>>7)&0x01;
	return r;
}


//256点 fft运算
//输入256个采样数据,只用实数部分，虚数为0
//输出128个频域数据,已将复数转换为幅度(频谱)
void FFT256(long* pInputData, long* pOutputData)
{
	double	real[256];
	double	imag[256];
	long	swap;
	long	offset;
	double	tmp_real, tmp_imag, temp;// 临时变量, 记录实部
	double	tw1, tw2;	// 旋转因子,tw1为旋转因子的实部cos部分, tw2为旋转因子的虚部sin部分.
	long	cur_layer, gr_num, i, k, p;      
	long	step;			// 步进
	long	sample_num;		// 颗粒的样本总数(各层不同, 因为各层颗粒的输入不同) 

	//虚部为0
	for(i=0; i<256; i++)
	{
		imag[i] = 0;
		real[i] = 0;
	}
	
	//倒位序
	for(i=0; i<256; i++)
	{
		swap = bitrev((unsigned char)i);
		real[swap] = (float)pInputData[i];
	}
	
	// 对层循环
	for(cur_layer=1; cur_layer<=8; cur_layer++)	//2^8=256,所以循环8次
	{      
		// 求当前层拥有多少个颗粒(gr_num)
		i = 8 - cur_layer;
		gr_num=1<<i;
		//每个颗粒的输入样本数N
		sample_num = 1<<cur_layer;
		//步进. 步进是N/2
		step = sample_num/2;
		k = 0;
		//对颗粒进行循环
		for(i=0; i<gr_num; i++)
		{
			//对样本点进行循环, 注意上限和步进				
			for(p=0; p<sample_num/2; p++)
			{   
				offset = p*gr_num;
				tw1 = cosTable[offset];
				tw2 = sinTable[offset];
				tmp_real = real[k+p];
				tmp_imag = imag[k+p];
				temp = real[k+p+step];             
				//蝶形算法
				real[k+p]   = tmp_real + ( tw1*real[k+p+step] - tw2*imag[k+p+step] );
				imag[k+p]   = tmp_imag + ( tw2*real[k+p+step] + tw1*imag[k+p+step] );
				real[k+p+step] = tmp_real - ( tw1*temp - tw2*imag[k+p+step] );
				imag[k+p+step] = tmp_imag - ( tw2*temp + tw1*imag[k+p+step] );             
			}
			//开跳
			k += 2*step;
		}   
	}
	
	//对复数求平方根
	for(i=0; i<128;i++)
	{
		temp = real[i]*real[i] + imag[i]*imag[i];
		temp = sqrt_fast(temp);
		pOutputData[i] = (long)temp;
	}
}



FFT总结
Sat, 08 Mar 2014 13:53:12 +0000
FFT是离散傅立叶变换的快速算法，可以将一个信号变换到频域。
一个模拟信号，经过ADC采样之后，就变成了数字信号。
采样得到的数字信号，就可以做FFT变换了。
N个采样点，经过FFT之后，就可以得到N个点的FFT结果。
为了方便进行FFT运算，通常N取2的整数次方。
假设采样频率为Fs，信号频率F，采样点数为N。
那么FFT之后结果就是一个为N点的复数。
每一个点就对应着一个频率点。
第n点所表示的频率为：Fn=(n-1)*Fs/N。
FFT的结果是中心对称，中心点频率为Fs/2。
假设原始信号的峰值为A，那么FFT的结果的每个点的模值就是A的N/2倍。
第一个点例外，是直流分量，它的模值就是直流分量的N倍。


WAV音频文件格式
Fri, 07 Mar 2014 17:34:54 +0000

  
      
          起始地址
          占用空间
          本地址数字的含义
      
  
  
      
          00H
          4byte
          RIFF，资源交换文件标志。
      
      
          04H
          4byte
          从下一个地址开始到文件尾的总字节数。高位字节在后面，这里就是001437ECH，换成十进制是1325036byte，算上这之前的8byte就正好1325044byte了。
      
      
          08H
          4byte
          WAVE，代表wav文件格式。
      
      
          0CH
          4byte
          FMT ，波形格式标志
      
      
          10H
          4byte
          00000010H，16PCM，我的理解是用16bit的数据表示一个量化结果。
      
      
          14H
          2byte
          为1时表示线性PCM编码，大于1时表示有压缩的编码。这里是0001H。
      
      
          16H
          2byte
          1为单声道，2为双声道，这里是0001H。
      
      
          18H
          4byte
          采样频率，这里是00002B11H，也就是11025Hz。
      
      
          1CH
          4byte
          Byte率=采样频率音频通道数每次采样得到的样本位数/8，00005622H，也就是22050Byte/s=11025116/2。
      
      
          20H
          2byte
          块对齐=通道数每次采样得到的样本位数/8，0002H，也就是2=116/8。
      
      
          22H
          2byte
          样本数据位数，0010H即16，一个量化样本占2byte。
      
      
          24H
          4byte
          data，一个标志而已。
      
      
          28H
          4byte
          Wav文件实际音频数据所占的大小，这里是001437C8H即1325000，再加上2CH就正好是1325044，整个文件的大小。
      
      
          2CH
          不定
          量化数据。
      
  



GCC编译静态库和动态库
Wed, 22 Jan 2014 17:23:50 +0000
一、动态库的编译和使用 ```cpp
//hello.c
#include<stdio.h>

void hello()

{
printf(“This is hello!\n”);

}

编译命令：gcc -shared hello.c -o libhello.so

可以看到，当前目录下多了一个文件libhello.so



测试test.c

```cpp
//test.c
#include<stdio.h>
int main()
{
	printf("call hello()\n");
	hello();
}
编译这个测试程序：gcc test.c -lhello -L. -o test
-lhello 指定要连接的库，文件名默认规则是libxxx.so
-L . 是指定库的目录
注意：编译成功但是执行会出错，执行是动态连接这个库会找不到路径，可以复制libhello.so到 /usr/lib等共用lib目录
或者修改环境变量export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
二、静态库的编译和使用
编译命令：gcc -c hello.c   这里会生成hello.o
生成静态库：ar -r libhello.a hello.o   将hello.o插入静态库
编译测试程序：
gcc test.c -lhello -L. -static -o hello.out
gcc test.c libhello.a -L. -o hello.out


USB描述符结构说明
Thu, 19 Dec 2013 11:36:24 +0000
转载出处： http://justmei.blog.163.com/blog/static/11609985320102421659260/?latestBlog
USB是个通用的总线，端口都是统一的。但是USB设备却各种各样，例如USB鼠标，USB键盘，U盘等等，那么USB主机是如何识别出不同的设备的呢？这就要依赖于描述符了。USB的描述符主要有设备描述符，配置描述符，接口描述符，端点描述符，字符串描述符，HID描述符，报告描述符等等。
一个USB设备有一个设备描述符，设备描述符里面决定了该设备有多
少种配置，每种配置描述符对应着配置描述符；而在配置描述符中又定义
了该配置里面有多少个接口，每个接口有对应的接口描述符；在接口描
述符里面又定义了该接口有多少个端点，每个端点对应一个端点描述符；
端点描述符定义了端点的大小，类型等等。由此我们可以看出，USB的
描述符之间的关系是一层一层的，最上一层是设备描述符，下面是配置
描述符，再下面是接口描述符，再下面是端点描述符。在获取描述符时，
先获取设备描述符，然后再获取配置描述符，根据配置描述符中的配置
集合长度，一次将配置描述符、接口描述符、端点描述符一起一次读回。
其中可能还会有获取设备序列号，厂商字符串，产品字符串等。
每种描述符都有自己独立的编号，如下：
#define DEVICE_DESCRIPTOR               0x01  //设备描述符

#define CONFIGURATION_DESCRIPTOR        0x02  //配置描述符

#define STRING_DESCRIPTOR 0x03 //字符串描述符

#define INTERFACE_DESCRIPTOR            0x04  //接口描述符

#define ENDPOINT_DESCRIPTOR             0x05  //端点描述符
下面分别详细介绍一下各描述符。
1.设备描述符
//定义标准的设备描述符结构
typedef struct _DEVICE_DCESCRIPTOR_STRUCT

{

 BYTE blength;                               //设备描述符的字节数大小

 BYTE bDescriptorType;                      //设备描述符类型编号

 WORD bcdUSB;                                //USB版本号

 BYTE bDeviceClass;                          //USB分配的设备类代码

 BYTE bDeviceSubClass;                       //USB分配的子类代码

 BYTE bDeviceProtocol; //USB分配的设备协议代码

 BYTE bMaxPacketSize0;                       //端点0的最大包大小

 WORD idVendor;                              //厂商编号

 WORD idProduct;                             //产品编号

 WORD bcdDevice;                             //设备出厂编号

 BYTE iManufacturer;                         //设备厂商字符串的索引

 BYTE iProduct;                              //描述产品字符串的索引

 BYTE iSerialNumber; //描述设备序列号字符串的索引

 BYTE bNumConfigurations;                    //可能的配置数量

}

DEVICE_DESCRIPTOR_STRUCT, * pDEVICE_DESCRIPTOR_STRUCT;
//实际的设备描述符示例


VC/MFC MFC中保存ini配置文件，代码片段
Tue, 17 Dec 2013 17:25:15 +0000
//在xxxApp::InitInstance()函数里面添加以下内容
delete m_pszProfileName;
delete m_pszRegistryKey;
m_pszRegistryKey = NULL;	//如果不为空则会把配置存在注册表里面
m_pszProfileName = _wcsdup(L"./config.ini");//ini文件路径，可以修改为绝对路径
然后就可以使用这一类函数来读写配置了
GetProfileInt(L"Section", L"Name",nValue);
WriteProfileInt(L"Section", L"Name", nValue);


VC/MFC 文件选择和文件夹选择，代码片段
Tue, 17 Dec 2013 17:15:06 +0000
1、批量选择文件
// 批量添加文件列表
void AddFile()
{
	CString		szFileName;
	CString		szCount;
	POSITION	pos;
	int		i;
	int		nCount=0;		//文件数量
	//输入文件
	CFileDialog InFile( TRUE,NULL,NULL,OFN_FILEMUSTEXIST|OFN_ALLOWMULTISELECT,_T("某种格式|*.fmt|所有文件(*.*)|*.*||") );
	InFile.m_ofn.nMaxFile  = 10000;		//文件上限
	InFile.m_ofn.lpstrFile = (LPWSTR)malloc(InFile.m_ofn.nMaxFile*sizeof(TCHAR));
	memset(InFile.m_ofn.lpstrFile,0,InFile.m_ofn.nMaxFile);

	//按了OK按钮，开始获取文件列表
	if(InFile.DoModal() == IDOK)
	{
		pos=InFile.GetStartPosition(); 
		while(pos)
		{	
			szFileName=InFile.GetNextPathName(pos);
			//这里szFileName就是文件路径
			//做点什么事情，比如添加到列表框
		}
	}
	//释放空间
	free(InFile.m_ofn.lpstrFile);
}
2、选择文件夹
void SelectPath()
{
	//选择输出路径
	TCHAR szDir[MAX_PATH];
	BROWSEINFO bi; 
	ITEMIDLIST *pidl; 
	bi.hwndOwner = this->m_hWnd; 
	bi.pidlRoot = NULL;
	bi.pszDisplayName = szDir;//这个是输出缓冲区 
	bi.lpszTitle = _T("选择输出文件夹："); //标题
	bi.ulFlags = BIF_NEWDIALOGSTYLE;//使用新的界面,在win7中效果较好//BIF_RETURNONLYFSDIRS; 
	bi.lpfn = NULL;
	bi.lParam = 0;
	bi.iImage = 0;
	pidl = SHBrowseForFolder(&bi);//弹出对话框 
	if (pidl == NULL)//点了取消，或者选择了无效的文件夹则返回NULL
		return;
	
	if(SHGetPathFromIDList(pidl, szDir)) 
		szDir = szDir;//szDir就是要获取的文件夹	
	//得到之后做点什么
}



VC/MFC 访问进程内存，代码片段
Tue, 17 Dec 2013 16:55:49 +0000
#include "StdAfx.h"
#include <TlHelp32.h>
#include "ProcessMemory.h"

//打开进程内存
BOOL CProcessMemory::Open(INT nPID)
{
	HANDLE hToken;
	INT    nFlag;
	nFlag = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken);
	if(!nFlag)
	{
		OutputDebugString(_T("OpenProcessToken Fail!\n"));
		return 0;
	}
	SetPrivilege(hToken, SE_DEBUG_NAME, TRUE);
	::CloseHandle(hToken);
	m_hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, nPID);
	if (m_hProc == INVALID_HANDLE_VALUE)
		return FALSE;
	return TRUE;
}

BOOL CProcessMemory::Open(LPCTSTR pzProcessName)
{
	INT nPID;
	nPID = GetProcessID(pzProcessName);
	return Open(nPID);
}

//设置进程权限
int CProcessMemory::SetPrivilege(HANDLE hToken, LPCTSTR lpszStr, BOOL bEnable)
{
	TOKEN_PRIVILEGES tp;
	LUID luid;

	BOOL bRet;
	bRet = LookupPrivilegeValue(NULL, lpszStr, &luid);
	if(bRet == FALSE)
	{
		OutputDebugString(_T("Lookup Privilege Value Fail!\n"));
		return FALSE;
	}

	tp.PrivilegeCount = 1;
	tp.Privileges[0].Luid = luid;

	if(bEnable)
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
	else
		tp.Privileges[0].Attributes = 0;

	bRet = AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), NULL, NULL);
	return bRet;
}


//写入
DWORD CProcessMemory::Write(LPVOID lpBaseAddress,  LPVOID lpBuffer, DWORD nSize)
{
	BOOL  bRet;
	DWORD dwReaded = 0;

	//句柄无效
	if(m_hProc == NULL)
		return FALSE;

	bRet = ::WriteProcessMemory(m_hProc, lpBaseAddress, lpBuffer, nSize, &dwReaded);
	if (bRet == FALSE)
		dwReaded = 0;
	return dwReaded;
}

//读取
DWORD CProcessMemory::Read(LPCVOID  lpBaseAddress,  LPVOID lpBuffer, DWORD nSize)
{
	BOOL  bRet;
	DWORD dwReaded = 0;

	//句柄无效
	if(m_hProc == NULL)
		return FALSE;

	bRet = ::ReadProcessMemory(m_hProc, lpBaseAddress, lpBuffer, nSize, &dwReaded);
	if (bRet == FALSE)
		dwReaded = 0;
	return dwReaded;
}

//关闭
void CProcessMemory::Close()
{
	if (m_hProc)
	{
		::CloseHandle(m_hProc);
	}
}

//根据进程名，返回第一个进程实例的PID
INT CProcessMemory::GetProcessID(LPCTSTR pzProcessName)
{	
	BOOL bRet;
	CString szExeName(pzProcessName);
	HANDLE hProcess;
	PROCESSENTRY32 procEntry;
	procEntry.dwSize = sizeof(PROCESSENTRY32); 
	
	//进行进程快照
	hProcess=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
	//开始进程查找
	bRet=Process32First(hProcess,&procEntry);

	//循环比较，得出ProcessID
	while(bRet)
	{
		if(0 == szExeName.Compare(procEntry.szExeFile))
			return procEntry.th32ProcessID;
		bRet=Process32Next(hProcess,&procEntry);
	}
	return 0;
}
VC/MFC 访问进程内存，代码片段


VC/MFC 键盘钩子，代码片断
Tue, 17 Dec 2013 16:30:49 +0000
在MFC程序中使用键盘钩子来获取按键消息，例程：
#include "StdAfx.h"
#include "KeyboardHook.h"
static HHOOK g_hHook = NULL;
static CWnd* g_pWnd  = NULL;

BOOL CKeyboardHook::Init(HINSTANCE hInst, CWnd *pWnd)
{
	g_pWnd = pWnd;
	g_hHook = SetWindowsHookEx(WH_KEYBOARD_LL,CKeyboardHook::KeyboardHookProc,hInst,NULL);
	return g_hHook == NULL ? FALSE : TRUE;
}

void CKeyboardHook::Close()
{
	UnhookWindowsHookEx(g_hHook);
}

LRESULT CALLBACK CKeyboardHook::KeyboardHookProc(int code, WPARAM wParam, LPARAM lParam)
{
	if(code == HC_ACTION)
	{
		PKBDLLHOOKSTRUCT pStruct = (PKBDLLHOOKSTRUCT)lParam;
		switch(pStruct->vkCode)
		{
		case 'a':
		case 'A':
		case 's':
		case 'S':
		case 'd':
		case 'D':
		case 'j':
		case 'J':
		case ' ':
			if (wParam == WM_KEYDOWN)
			{
				g_pWnd->PostMessage(WM_KEYDOWN, pStruct->vkCode, pStruct->scanCode);                               
			}
			return TRUE;
			break;
		default:  return CallNextHookEx(g_hHook, code, wParam, lParam);
		}
	}
	return CallNextHookEx(g_hHook, code, wParam, lParam);
}



WMV文件格式
Wed, 16 Oct 2013 09:48:14 +0000
wma文件结构示意图
格式的简单说明：
如图1，每一个WMA文件，它的 头16个字节是固定的 ，为十六进制的“30 26 B2 75 8E 66 CF 11 A6 D9 00 AA 00 62 CE 6C”，用来标识这个是否为WMA文件。接下来的 8个字节为一个整数，表示整个WMA文件头部的大小 ，这个头部里面包含了Tag信息等所有非音频信息， 头部后面的是音频信息 ，我们在这里就不深入了解了。那个整数接下来的6个字节还没搞清楚是什么用的，不过不影响我们对Tag信息的读写。
也就是说从文件开始偏移量为31开始，里面存放了很多帧，有我们需要的 标准Tag信息，扩展Tag信息，WMA文件控制信息等等 。每个帧 不是等长 的，但是 帧头是固定的24个字节，其中前16字节是用来标识这个帧的名字，后8个字节是用来表示这个帧（包括帧头）的大小 。这一点和MP3文件的ID3V2信息比 较像。
由于我们只需要读写Tag信息，而Tag信息又分别保存在两个帧里，分别为标准Tag帧和扩展Tag帧，所有我们只需要处理这两个帧，其他帧完全可以根据获得的帧长度来跳过。
如图2，标 准Tag帧只包含歌曲标题，艺术家，版权，备注四个内容 。它的帧名是十六进制的“3326 B2 75 8E 66 CF 11 A6 D9 00 AA 00 62 CE 6C”，在24个字节的帧头后紧跟着5个分别为2个字节的整数，分别表示歌曲标题，艺术家，版权，备注，未知信息的大小，未知信息大部分情况下是不使用的，即它的大小为0的。
在这10个字节后，这五个信息的内容就按顺序存放了。记住，在WMA文件里，所有的文字都是按Unicode宽字符的编码方式储存的，而且每个字符串后面都有一个0x00 0x00结束字符的。
如图3，再看扩展Tag帧，这里就比较麻烦了，里面包含的信息的个数是不确定的，每个信息也是按照像帧一样的方式组织起来的。扩展Tag帧的帧名是十六进制的“40 A4 D0 D2 07 E3 D2 11 97 F000 A0 C9 5E A8 50”，在 24字节的帧头(HeadFlag:16，HeadSize:8)后先有一个两个字节的整数表示这个帧里一共有的扩展信息个数（ExNo）。紧接着是扩展信息。
如图4，每一个扩展信息 包含扩展信息名字大小（2字节）和对应的内容 。先有一个两个字节的整数来表示扩展名字信息的大小，接着是扩展信息名称，然后有一个两个字节的整数标志（Flag）。然后又是一个两个字节的整数，表示值的大小。接着就是这个值。
当扩展信息名字为WMFSDKVersion时，这个值表示的是这个WMA文件的版本；


MP4文件格式
Wed, 16 Oct 2013 09:47:07 +0000
MP4 文件格式
综述
关键概念
MP4文件格式中，所有的内容存在一个称为 movie 的容器中。一个 movie 可以由多个 track s 组成。每个 track 就是一个随时间变化的媒体序列，例如，视频帧序列。 track 里的每个时间单位是一个 sample ，它可以是一帧视频，或者音频。 sample 按照时间顺序排列。注意，一帧音频可以分解成多个音频 sample ，所以音频一般用 sample 作为单位，而不用帧。MP4
文件格式的定义里面，用 sample 这个单词表示一个时间帧或者数据单元。每个 track 会有一个或者多个 sample description s。 track 里面的每个 sample 通过引用关联到一个 sample description 。这个 sample description s
定义了怎样解码这个 sample ，例如使用的压缩算法。与其他的多媒体文件格式不同的是，MP4 文件格式经常使用几个不同的概念，理解其不同是理解这个文件格式的关键。
这个文件的物理格式没有限定媒体本身的格式。例如，许多文件格式将媒体数据分成帧，头部或者其他数据紧紧跟随每一帧视频，！！！TODO（例如MPEG2）。而MP4 文件格式不是如此。文件的物理格式和媒体数据的排列都不受媒体的时间顺序的限制。视频帧不需要在文件按时间顺序排列。这就意味着如果文件中真的存在这样的一些帧，那么就有一些文件结构来描述媒体的排列和对应的时间信息。
MP4文件中所有的数据都封装在一些 box 中（以前叫 atom ）。所有的metadata(媒体描述元数据)，包括定义媒体的排列和时间信息的数据都包含在这样的一些结构 box 中。MP4 文件格式定义了这些这些 box 的格式。Metadata 对媒体数据（例如，视频帧）引用说明。媒体数据可以包含在同一个的一个或多个 box 里，也可以在其他文件中，metadata
允许使用URLs 来引用其他的文件，而媒体数据在这些引用文件中的排列关系全部在第一个主文件中的metadata 描述。其他的文件不一定是MP4 文件格式，例如，可能就没有一个box。
有很多种类的 track ，其中有三个最重要， video track 包含了视频 sample ； audio track 包含了audio sample ； hint track 稍有不同，它描述了一个流媒体服务器如何把文件中的媒体数据组成符合流媒体协议的数据包。如果文件只是本地播放，可以忽略 hint track ，他们只与流媒体有关系。


FLV文件格式
Wed, 16 Oct 2013 09:43:42 +0000
[ 
](http://photo.blog.sina.com.cn/showpic.html#blogid=48f93b530100eyoe&url=http://s6.sinaimg.cn/orignal/48f93b53g74f5adde2875&690)
其中，Previous Tag Size紧跟在每个Tag之后，占4个字节表示一个UI32类型的数值，表示前面一个Tag的大小。需要注意的是，Previous Tag Size #0的值总是为0。Tag类型包括视频、音频和Script，且每个Tag只能包含一种类型的数据。下面我们看看File Header和Tag的具体结构，为了方便大家理解，我贴一个实际FLV文件的字节流图片，图片中把不同部分区分了颜色。
[ 
](http://photo.blog.sina.com.cn/showpic.html#blogid=48f93b530100eyoe&url=http://s1.sinaimg.cn/orignal/48f93b53g74f5d8e518d0&690)
一、File Header结构
File Header在当前版本中总是由9个字节组成，如图中蓝色区域所示。
第1-3字节为文件标识（Signature），总为“FLV”（0x46 0x4C 0x56），如图中紫色区域。
第4字节为版本，目前为1（0x01）。
第5个字节的前5位保留，必须为0。
第5个字节的第6位表示是否存在音频Tag。
第5个字节的第7位保留，必须为0。
第5个字节的第8位表示是否存在视频Tag。
第6-9个字节为UI32类型的值，表示从File Header开始到File Body开始的字节数，版本1中总为9。
二、Previous Tag Size结构
如图中红色位置所示。
三、Tag结构
Tag包括Tag Header和Tag Data两部分。不同类型的Tag的Header结构是相同的，但是Data结构各不相同。如图中绿色和黄色区域分别表示Tag Header数据和Tag Data数据。
当前版本的Tag Header结构占用11个字节。
第1个字节表示Tag类型，包括音频（0x08）、视频（0x09）和script data（0x12），其他类型值被保留。
第2-4字节为UI24类型的值，表示该Tag Data部分的大小。
第5-7字节为UI24类型的值，表示该Tag的时间戳（单位为ms），第一个Tag的时间戳总是0。
第8个字节为时间戳的扩展字节，当24位数值不够时，该字节作为最高位将时间戳扩展为32位值。
第9-11字节为UI24类型的值，表示stream id，总是0。
后面的字节为Tag Data数据，Data的大小由第2-4字节的数值指示，根据第1个字节指示的Tag类型，按照不同的结构解析Tag Data。下面分别介绍。
四、Audio Tag Data结构
音频Tag开始的第1个字节包含了音频数据的参数信息，从第2个字节开始为音频流数据。
第1个字节的前4位的数值表示了音频数据格式，各值代表的意义大家可以查阅Adobe公司发布的FLV格式说明文档（可以到我的磁盘空间的“资料”目录去下载 http://e.ys168.com/?tinyfun ）。
第1个字节的第5-6位的数值表示采样率，0 = 5.5 kHz，1 = 11 kHz，2 = 22 kHz，3 = 44 kHz。
第1个字节的第7位表示采样精度，0 = 8bits，1 = 16bits。


AVI文件格式
Wed, 16 Oct 2013 09:41:14 +0000
AVI（Audio Video Interleaved的缩写）是一种RIFF（Resource Interchange File Format的缩写）文件格式，多用于音视频捕捉、编辑、回放等应用程序中。通常情况下，一个AVI文件可以包含多个不同类型的媒体流（典型的情况下有一个音频流和一个视频流），不过含有单一音频流或单一视频流的AVI文件也是合法的。AVI可以算是Windows操作系统上最基本的、也是最常用的一种媒体文件格式。
先来介绍RIFF文件格式。RIFF文件使用四字符码FOURCC（four-character code）来表征数据类型，比如‘RIFF’、‘AVI ’、‘LIST’等。注意，Windows操作系统使用的字节顺序是little-endian，因此一个四字符码‘abcd’实际的DWORD值应为0x64636261。另外，四字符码中像‘AVI ’一样含有空格也是合法的。
RIFF文件首先含有一个如图3.31的文件头结构。

图3.31 RIFF文件结构
最开始的4个字节是一个四字符码‘RIFF’，表示这是一个RIFF文件；紧跟着后面用4个字节表示此RIFF文件的大小；然后又是一个四字符码说明文件的具体类型（比如AVI、WAVE等）；最后就是实际的数据。注意文件大小值的计算方法为：实际数据长度 + 4（文件类型域的大小）；也就是说，文件大小的值不包括‘RIFF’域和“文件大小”域本身的大小。
RIFF文件的实际数据中，通常还使用了列表（List）和块（Chunk）的形式来组织。列表可以嵌套子列表和块。其中，列表的结构为：‘LIST’ listSize listType listData ——‘LIST’是一个四字符码，表示这是一个列表；listSize占用4字节，记录了整个列表的大小；listType也是一个四字符码，表示本列表的具体类型；listData就是实际的列表数据。注意listSize值的计算方法为：实际的列表数据长度 + 4（listType域的大小）；也就是说listSize值不包括‘LIST’域和listSize域本身的大小。再来看块的结构：ckID
ckSize ckData ——ckID是一个表示块类型的四字符码；ckSize占用4字节，记录了整个块的大小；ckData为实际的块数据。注意ckSize值指的是实际的块数据长度，而不包括ckID域和ckSize域本身的大小。（注意：在下面的内容中，将以LIST ( listType ( listData ) )的形式来表示一个列表，以ckID ( ckData )的形式来表示一个块，如[ optional element ]中括号中的元素表示为可选项。）
接下来介绍AVI文件格式。AVI文件类型用一个四字符码‘AVI ’来表示。整个AVI文件的结构为：一个RIFF头 + 两个列表（一个用于描述媒体流格式、一个用于保存媒体流数据） + 一个可选的索引块。AVI文件的展开结构大致如下：
RIFF (‘AVI ’
LIST (‘hdrl’
‘avih’(主AVI信息头数据)
LIST (‘strl’
‘strh’ (流的头信息数据)
‘strf’ (流的格式信息数据)
[‘strd’ (可选的额外的头信息数据) ]
[‘strn’ (可选的流的名字) ]
…
)
…
)
LIST (‘movi’
{ SubChunk | LIST (‘rec ’
SubChunk1
SubChunk2
…
)
…
}
…
)
[‘idx1’ (可选的AVI索引块数据) ]
)


MP3文件格式
Wed, 16 Oct 2013 09:35:45 +0000
 一、概述 
MP3 文件是由帧(frame)构成的,帧是 MP3 文件最小的组成单位。MP3 的全称应为 MPEG1 Layer-3 音频
文件,MPEG(Moving Picture Experts Group)在汉语中译为活动图像专家组,特指活动影音压缩标准,MPEG
音频文件是 MPEG1 标准中的声音部分,也叫 MPEG 音频层,它根据压缩质量和编码复杂程度划分为三层,即
Layer-1、Layer2、Layer3,且分别对应 MP1、MP2、MP3 这三种声音文件,并根据不同的用途,使用不同层
次的编码。MPEG 音频编码的层次越高,编码器越复杂,压缩率也越高,MP1 和 MP2 的压缩率分别为 4:1 和
6:1-8:1,而 MP3 的压缩率则高达 10:1-12:1,也就是说,一分钟 CD 音质的音乐,未经压缩需要 10MB
的存储空间,而经过 MP3 压缩编码后只有 1MB 左右。不过 MP3 对音频信号采用的是有损压缩方式,为了降
低声音失真度,MP3 采取了“感官编码技术”,即编码时先对音频文件进行频谱分析,然后用过滤器滤掉
噪音电平,接着通过量化的方式将剩下的每一位打散排列,最后形成具有较高压缩比的 MP3 文件,并使压
缩后的文件在回放时能够达到比较接近原音源的声音效果。
 二、整个MP3  文件结构
MP3文件大体分为三部分：TAG_V2(ID3V2)，Frame, TAG_V1(ID3V1)
ID3V2
包含了作者，作曲，专辑等信息，长度不固定，扩展了ID3V1的信息量。
Frame
.
.
.
Frame
一系列的帧，个数由文件大小和帧长决定
每个FRAME的长度可能不固定，也可能固定，由位率bitrate决定
每个FRAME又分为帧头和数据实体两部分
帧头记录了mp3的位率，采样率，版本等信息，每个帧之间相互独立
ID3V1
包含了作者，作曲，专辑等信息，长度为128BYTE。
 三、MP3  帧格式
 1.  帧头格式
帧头长4字节，对于固定位率的MP3文件，所有帧的帧头格式一样其数据结构如下：


可能会用到的一些网页，先存在这里免得以后找不到
Tue, 03 Sep 2013 10:36:10 +0000
流媒体相关：
http://www.rosoo.net/a/201012/10570.html
Linux相关：
https://www.kernel.org/
http://www.linaro.org/


Makefile参考样例1：单文件夹多个.c和.h的编译
Mon, 02 Sep 2013 17:01:03 +0000
以下makefile比较简单，适用于所有源码在一个文件夹下面；
缺点：编译的时候没有检查.h文件修改，所以修改了.h文件需要clean之后重新编译.
SRCDIR:=.
OBJDIR:=.

CC:=gcc
STRIP:=strip

CFLAGS:=-w -O2 

.PHONY: all
.DEFAULT: all

OBJDIR:=./obj
SRCS:=$(wildcard $(SRCDIR)/*.c)
OBJS:=$(addprefix $(OBJDIR)/,$(patsubst %.c,%.o,$(SRCS)))

PROGRAM:=main.elf

all: $(PROGRAM)

$(OBJS): $(OBJDIR)/%.o : %.c
	@if [ ! -d $(dir $@) ] ; then mkdir -v -p $(dir $@) ; fi
	@echo compile: $<
	$(CC) $(CFLAGS) -c $< -o $@

$(PROGRAM): $(OBJS)
	$(CC) $(OBJS) -o $(PROGRAM) -lpthread -static
	$(STRIP) $(PROGRAM)

clean:
	rm -f $(OBJDIR)/* $(PROGRAM)



arm linux挂载nfs根文件系统
Mon, 02 Sep 2013 16:51:41 +0000
一、在主机里安装nfs服务
apt-get install nfs-kernel-server
配置nfs输出目录：/etc/exports
在该文件中添加一行：/home/arm *(rw,sync,no_root_squash)  根据实际情况修改/home/arm为想要的路径就行了。
二、编译arm linux内核勾选nfs client
[Filesystem] -> Mi………………
三、设置启动参数
[仅供参考]
“root=/dev/nfs init=/sbin/init console=ttySAC0 nfsroot=192.168.0.100:/home/arm ip=192.168.0.101”


Linux启动参数
Mon, 02 Sep 2013 16:45:21 +0000
U-boot的环境变量值得注意的有两个： bootcmd 和bootargs。
u-bootcmd
前面有说过bootcmd是自动启动时默认执行的一些命令，因此你可以在当前环境中定义各种不同配置，不同环境的参数设置，然后设置bootcmd为你经常使用的那种参数。
u-bootargs
bootargs是环境变量中的重中之重，甚至可以说整个环境变量都是围绕着bootargs来设置的。bootargs的种类非常非常的多，我们平常只是使用了几种而已，感兴趣的可以看看这篇文章说的很全：http://blog.chinaunix.net/u2/79570/showart_1675071.html。bootargs非常的灵活，内核和文件系统的不同搭配就会有不同的设置方法，甚至你也可以不设置bootargs,而直接将其写到内核中去（在配置内核的选项中可以进行这样的设置），正是这些原因导致了bootargs使用上的困难。
下面介绍一下bootargs常用参数，bootargs的种类非常的多，而且随着kernel的发展会出现一些新的参数，使得设置会更加灵活多样。
A. root
用来指定rootfs的位置， 常见的情况有:
root=/dev/ram rw
root=/dev/ram0 rw
请注意上面的这两种设置情况是通用的，我做过测试甚至root=/dev/ram1 rw和root=/dev/ram2 rw也是可以的，网上有人说在某些情况下是不通用的，即必须设置成ram或者ram0，但是目前还没有遇到，还需要进一步确认，遇到不行的时候可以逐一尝试。
root=/dev/mtdx rw
root=/dev/mtdblockx rw
root=/dev/mtdblock/x rw
root=31:0x
上面的这几个在一定情况下是通用的，当然这要看你当前的系统是否支持，不过mtd是字符设备，而mtdblock是块设备，有时候你的挨个的试到底当前的系统支持上面那种情况下，不过root=/dev/mtdblockx rw比较通用。此外，如果直接指定设备名可以的话，那么使用此设备的设备号也是可以的。
root=/dev/nfs
在文件系统为基于nfs的文件系统的时候使用。当然指定root=/dev/nfs之后，还需要指定nfsroot=serverip:nfs_dir，即指明文件系统存在那个主机的那个目录下面。
B. rootfstype
这个选项需要跟root一起配合使用，一般如果根文件系统是ext2的话，有没有这个选项是无所谓的，但是如果是jffs2,squashfs等文件系统的话，就需要rootfstype指明文件系统的类型，不然会无法挂载根分区.
C. console
console=tty  使用虚拟串口终端设备 .
console=ttyS[,options] 使用特定的串口，options可以是这样的形式bbbbpnx，这里bbbb是指串口的波特率，p是奇偶位（从来没有看过使用过），n是指的bits。
console=ttySAC[,options] 同上面。
看你当前的环境，有时用ttyS，有时用ttySAC，网上有人说，这是跟内核的版本有关，2.4用ttyS，2.6用ttySAC，但实际情况是官方文档中也是使用ttyS，所以应该是跟内核版本没有关联的。可以查看Documentation/serial-console.txt找到相关描述。
D. mem
mem=xxM 指定内存的大小，不是必须的
E. ramdisk_size
ramdisk=xxxxx           不推荐
ramdisk_size=xxxxx   推荐
上面这两个都可以告诉ramdisk 驱动，创建的ramdisk的size，默认情况下是4m(s390默认8M)，你可以查看Documentation/ramdisk.txt找到相关的描述，不过ramdisk=xxxxx在新版的内核都已经没有提了，不推荐使用。
F. initrd, noinitrd
当你没有使用ramdisk启动系统的时候，你需要使用noinitrd这个参数，但是如果使用了的话，就需要指定initrd=r_addr,size, r_addr表示initrd在内存中的位置，size表示initrd的大小。
G. init
init指定的是内核启起来后，进入系统中运行的第一个脚本，一般init=/linuxrc, 或者init=/etc/preinit，preinit的内容一般是创建console,null设备节点，运行init程序，挂载一些文件系统等等操作。请注意，很多初学者以为init=/linuxrc是固定写法，其实不然，/linuxrc指的是/目录下面的linuxrc脚本，一般是一个连接罢了。
H. mtdparts
mtdparts=fc000000.nor_flash:1920k(linux),128k(fdt),20M(ramdisk),4M(jffs2),38272k(user),256k(env),384k(uboot)
要想这个参数起作用，内核中的mtd驱动必须要支持，即内核配置时需要选上Device Drivers  —> Memory Technology Device (MTD) support  —> Command line partition table parsing


GCC编译生成bin
Mon, 02 Sep 2013 16:44:42 +0000
#连接
arm-linux-ld -Tboot.lds -o a.out $^
#将elf文件转换为bin
arm-linux-objcopy -O binary -S a.out a.bin
#boot.lds文件
SECTIONS {
. = 0x30000000;
.text          :   { (.text) }
.rodata ALIGN(4) : {(.rodata)}
.data ALIGN(4) : { *(.data) }
.bss ALIGN(4)  : { *(.bss)  *(COMMON) }
}


配置纯净版Debian开发环境
Mon, 02 Sep 2013 16:42:06 +0000
为了在虚拟机中编译使用linux环境开发一些软件需要用到Linux开发环境，而我不需要ubuntu之类的桌面系统，它太庞大了。
在实际开发中，使用虚拟机+Windows共享文件的方式，代码编辑在windows进行，而linux只需要make一下，所以我只需要一个控制台。
所以要自己安装一个精简的Linux开发环境。
发现Debian有一个网络安装系统的iso文件，很小只有200MB左右，安装完后什么都没有，只有控制台，非常nice！
这就是我想要的了，从这个最小系统为基础，开始搭建我的linux开发环境。
debian的所有版本安装包在这里下载：http://cdimage.debian.org/cdimage/archive/
下载好netinst.iso后，在安装的时候，选择：Advanced options –> Expert install
这样在安装的时候会有更多选择.比如可以选择只建立root账号，而不用建立一个无用的普通账号。
########################################################################################################################
常用配置文件
系统启动菜单：/boot/grub/grub.cfg
初始化脚本：/etc/init.d/
配置环境变量：/etc/profiles
配置环境变量：/etc/bash.bashrc
IP地址设置：/etc/networks/interface
DNS服务器： /etc/resolv.conf
安装包配置：/etc/apt/sources.list
########################################################################################################################
修改vim的配置
配置文件：/etc/vim/vimrc.tiny
添加代码：
set nocompatible
set backspace=2
set tabstop=4
########################################################################################################################
设置别名
配置文件：/etc/bash.bashrc
参考设置：
alias ls=‘ls –color’
alias ll=‘ls -l’
alias ps=‘ps - x’
########################################################################################################################
设置网络连接
配置文件：/etc/network/interfaces
自动获取IP
iface eth0 inet dhcp
静态IP地址：
iface eth0 inet static
address 192.168.0.100
gateway 192.168.0.1
netmask 255.255.255.0
DNS地址配置：
配置文件：/etc/resolv.conf
nameserver 192.168.0.1
手动配置命令：
ifconfig eth0 up
dhclient eth0
route add default gw 192.168.0.1


MFC加载纯资源DLL
Mon, 02 Sep 2013 16:33:14 +0000
不同语言的资源放到不同的DLL中，在运行时加载特定语言的DLL。
一、制作纯资源DLL
新建Win32工程，选择动态链接库。
在工程选项里，链接器 -> 高级 -> 无入口程序 = 是/NOENTRY
然后在资源里面添加想要的各种资源。
最后添加DLL入口程序
#include<windows.h>
extern	"C"
BOOL   WINAPI   DllMain(   HINSTANCE   hInstance,   DWORD   dwReason,   LPVOID)
{  
	return	TRUE;
}
编译完就会生成一个DLL。二、加载DLL
新建MFC工程，在xxxApp.cpp里面的::InitInstance()函数添加
    HINSTANCE   hDll;
    hDll = ::LoadLibrary(L"0804.dll");
    //使用图标资源    
    AfxSetResourceHandle(hDll); 
后面创建的对话框，资源等都会自动从该DLL的去实现。
哦，还有一个，resource.h资源头文件要使用资源那个工程的


手机在于折腾，历时5个月终于救回来了！
Tue, 07 May 2013 16:16:39 +0000
经历了5个月的研究，终于把我的手机救回来了。
之前的分析结果是正确的，PXA300启动过程是要加载NTIM，OBM，EBOOT，IPL。
不过这样是不能开机的，因为缺少EBOOTCFG，也就是EBOOT的启动参数，而这个启动参数却不包含在刷机ROM文件之中。
这就是导致我怎么折腾都不能启动的原因！
疑问就是这个启动参数不在ROM文件内，那它是怎么生成的呢？其内容也不会因为刷机而改变，那估计只能是厂家出厂的时候写进去的吧。
为了得到这个启动参数的内容，我在淘宝找到一个类似我手机的主板PXA310的，一个二手主板，拿回家用JTAG读Flash。
果然读到了128KB的EBOOTCFG，这里面的内容在ROM文件里是查不到的，我把这128KB写到我手机主板的FLASH里面，插上电池…
终于让我看到了久违的开机画面啊！！！太兴奋了啊，为了这个手机我花了多少的心血！
不过此时还是启动不了，因为NK部分已经残缺不全，不过这个问题很容易啦，重新进入USB Update Mode，刷入之前能用的ROM。OK
一切搞定！！！
在此保存一下研究结果，方便以后查询：
1、Nand存储结构：
Nand大小：256MB
共2048个块，块大小：128KB

  
      
          起始地址
      
  
  
  


  
      
          长度
      
  
  
  


  
      
          内容
      
  
  
  


  
      
          0x00000
          0x20000
          NTIM
      
  
  
      
          0x20000
          0x20000
          OBM
      
      
          0x40000
          0x40000
          EBOOT
      
      
          0x80000
          0x20000
          IPL
      
      
          0xA0000
          0x20000
          EBTCFG
      
      
          0xC0000
          0x60000
          LOGO
      
      
          0x120000
          ——
          MBR
      
  

2、主板JTAG接口

从2013-01-01到今日2013-05-05整整5个月，我早已买了Android手机，面对这个旧手机，似乎有种物是人非的感觉啊。


手机在于折腾，探索未知世界！
Sun, 13 Jan 2013 22:00:24 +0000
我最近折腾一个WM系统的手机。
手机和开发板的区别就在于：手机没有任何资料，而开发板有全套电路图+BSP源码！
为了探索手机中的未知世界，唯一的办法就是逆向工程，逆向分析最好的就是写程序去验证。
一个不知天高地厚的少年就开始折腾他的手机：
花了大量时间去寻找JTAG测试点   —–>成功
寻找支持PXA300的廉价JTAG工具 —–>成功
用JTAG访问NandFlash                  —–>  成功
写程序检测GPIO连接                     —–>  部分成功
后来他疯了，居然对Bootloader下毒手：
用JTAG把Flash清空了                 ——-> 成功了
验证手机肯定不能开机                  ——-> XD 成功了
他醒悟了：
用JTAG重新烧写Bootloader        ———> 成功了
验证手机重新开机                       ———->失败了！！！！
XD… 他崩溃了。。。。。
：：：为什么把原厂ROM中的Boot部分重新写入Flash就不能开机了呢…???


手机在于折腾，这下玩火自焚了...
Sun, 13 Jan 2013 21:38:54 +0000
前言 这是一个基于Marvell PXA300的WM6系统的手机。我前不久想把它当成“开发板”来折腾一下，写几个ARM的裸机程序来玩玩。
于是我对其进行大量逆向工程，现在我已经知道大部分GPIO连接方式和主板上的JTAG引脚。
我大胆地用JTAG把里面的Flash（型号：H8BCS0SI0MBR,256MB）给清空了，全部block,当然包括bootloader部分。
然后自然就无法开机了。我就可以自己写程序来用这个“开发板”了
现在想还原 我现在想把Bootloader还原，重新变成手机，发现问题来了，我虽然有这个手机原厂的ROM，文件名：SMART.UPR。
这个文件里面包括了Bootloader + OS Image + Modem CLA(NXP5209)。
我原来以为只要把这里面的bootloader部分重新写入Flash的0地址就可以解决问题。但是结果失败了！！！伤心啊~~~
后悔当初太冲动，应该先把Flash里面的内容备份出来再清空啊！！！
以下是分析过程
首先原厂ROM的结构：header + bootloader + NK + Modem，这个是确定无误的。
header 大小为0x400（1024B），就是对这个文件的一些描述，估计只有厂家才知道这些数据的格式。
bootloader，这部分结构为 IPL1 + NTIM + OBM + EBOOT + IPL2 + LOGO
IPL1和IPL2我不敢肯定哪个是真正的IPL，我感觉应该是 IPL2，原因是：
WM的启动过程是BootROM -> NTIM -> OBM -> EBOOT -> IPL -> OS
一般说来是按照顺序储存在NandFlash里面的。而这个IPL1的位置却放在最前面，我有点搞不懂它的作用。
通过反汇编（要是有源码看就不用反汇编了）可以看出来IPL1和IPL2有很多相同的代码。
IPL1为64KB，IPL2为128KB，其中IPL2添加了大量关于NXP5209的处理代码，所以我觉得IPL2应该才是正常启动用的IPL。
在IPL1这64KB中，有个明显的字符串：“Microsoft Windows CE IPL for Intel PXA 310 Zylonite”，这不科学呀！它应该在EBOOT的后面才对。
在Flash里面的储存结构理论上应该是下面这样：

  
      
          block5
          LOGO
          128KB
      
  
  
      
          block4
          IPL
          128KB
      
      
          block3
          EBOOT
          128KB
      
      
          block2
          EBOOT
          128KB
      
      
          block1
          OBM
          128KB
      
      
          block0
          NTIM
          128KB
      
  

PXA300的BootROM手册里面有关于NTIM的描述，所以我从SMART.ROM文件里的NTIM部分可以肯定NTIM,OBM,EBOOT的储存位置肯定是在Flash中从block0连续存放的。
我最先做的就是把NTIM+OBM+EBOOT一共512KB连续地放在Flash的第block0,1,2,3里面。
我原本以为这样就正确了，当我连接电源的时候，充电灯亮了，屏幕也亮了，但是按开机却一直黑屏。
我又试了以前常规的刷机方法，按Vol+Power，嗯，能进入USB Update Mode，一切看上去很正常，用刷机软件刷入smart.upr,重启还是黑屏，依旧不能开机。


QSV文件格式简单分析
Fri, 16 Mar 2012 19:00:49 +0000
QSV文件是奇艺为了保护版本而产生的一种文件格式。
但这一措施使得想在手机、平板等非PC平台上播放该视频带来严重不便，于是想方设法把QSV文件转换为别的平台可播放的格式。
前段时间我对奇艺的QSV文件格式也做了少量的研究。因为我也想在手机上播放奇艺影音下载的视频。
事实上奇艺的所有视频都是f4v格式的，f4v其实就是一种FLV格式，只是其视频编码采用的是H.264；
通过奇艺影音下载的视频都被奇艺影音加密处理了一下把后缀改成了QSV。
下面我就说说我研究QSV文件所得到的结论：
一个QSV文件包含文件头和视频数据加部分。
一、文件头部
1.QSV文件前面9个字节为固定“QIYI VIDEO”，文件格式标识符
2.第0A-0D字节，是QSV文件内部版本号，以前的QSV文件版本号都是01，现在奇艺已经更新版本号为02，当然结构也会跟着变化
3.第0E-1D字节，是视频ID号
4.第1E-45字节，作用暂时未知，大部分为0
5.第46-49字节，标识是否有视频信息，为1则有，为0则无
6.第4A-4D字节，视频信息的偏移值
7.第4E-51字节，全为0，作用未知
8.第52-55字节，视频信息的长度（视频信息为一段XML文件）
9.第56-59字节，视频分段数量（奇艺视频将一个F4V文件分成了若干段，一段大约6分钟）
10.第5A-5B字节，作用未知
—————–以下是F4V分段索引—————————–
11.第5B-6A字节，作用未知，猜测为本小段f4v文件的校验码
12.第6B-6E字节，本段F4V文件的偏移地址
13.第6F-72字节，全为0
13.第73-76字节，本小段F4V文件的长度
14.第77-86字节，下一段F4V的校验
15.第87-8A字节，下一段F4V的偏移地址
16……………………………

二、视频数据
从文件头部可以得到各个F4V分段的偏移地址和分段长度。
直接提取出来是不行的，因为奇艺对这些F4V文件进行了加密处理。
加密方式为：
将各F4V分段的前面1024字节进行加密，后面的没有加密。
加密算法为以4个字节为单位进行异或操作，异或的数据为0X79706762
附上QSV转换工具
QSV2FLV:  http://pan.baidu.com/share/home?uk=1526776463#category/type=0

CHS	简体中文
CHT	繁体中文
DEU	德语
ENU	英语
ESN	西班牙语
FRA	法语
ITA	意大利语
JPN	日语
KOR	朝鲜语
RUS	俄语
LOC	默认语言

漏洞编号	备注	补丁编号(Win7)
CVE-2017-0143	SMB	KB4012212
CVE-2017-0144	SMB	KB4012212
CVE-2017-0145	SMB	KB4012212
CVE-2017-0146	SMB	KB4012212
CVE-2017-0147	SMB	KB4012212
CVE-2017-0148	SMB	KB4012212
CVE-2017-11780	SMB	KB4041678
CVE-2019-0708	RDP	KB4499175
CVE-2019-1181	RDP	KB4512486
CVE-2019-1182	RDP	KB4512486

	文件系统	操作系统	引导方式
分区一(C:)	NTFS	Windows	Bootmgr
分区二(D:)	EXT4	Ubuntu	linux/initrd
分区三(E:)	HFS+	MacOSX	boot(变色龙)
分区四(F:)	FAT32	无	grldr

填充方式	帧率(FPS)	速度(Pixel/s)	备注
软件逐点填充	6	783360
软件逐行填充	63	8225280
软件矩形填充	69	9008640
硬件逐行填充1	201	26242560	先绘图，等待空闲后退出函数
硬件逐行填充2	207	27025920	进入函数先等待空闲，再绘图
硬件矩形填充1	312	40734720	先绘图
硬件矩形填充2	315	41126400	先等待

emWin(5.30)	126	16441000	自带驱动，支持硬件加速
FastGUI	201	26242560	驱动为硬件逐行填充2
FlatGUI	324	42301440

起始地址	占用空间	本地址数字的含义
00H	4byte	RIFF，资源交换文件标志。
04H	4byte	从下一个地址开始到文件尾的总字节数。高位字节在后面，这里就是001437ECH，换成十进制是1325036byte，算上这之前的8byte就正好1325044byte了。
08H	4byte	WAVE，代表wav文件格式。
0CH	4byte	FMT ，波形格式标志
10H	4byte	00000010H，16PCM，我的理解是用16bit的数据表示一个量化结果。
14H	2byte	为1时表示线性PCM编码，大于1时表示有压缩的编码。这里是0001H。
16H	2byte	1为单声道，2为双声道，这里是0001H。
18H	4byte	采样频率，这里是00002B11H，也就是11025Hz。
1CH	4byte	Byte率=采样频率音频通道数每次采样得到的样本位数/8，00005622H，也就是22050Byte/s=11025116/2。
20H	2byte	块对齐=通道数每次采样得到的样本位数/8，0002H，也就是2=116/8。
22H	2byte	样本数据位数，0010H即16，一个量化样本占2byte。
24H	4byte	data，一个标志而已。
28H	4byte	Wav文件实际音频数据所占的大小，这里是001437C8H即1325000，再加上2CH就正好是1325044，整个文件的大小。
2CH	不定	量化数据。

0x00000	0x20000	NTIM
0x20000	0x20000	OBM
0x40000	0x40000	EBOOT
0x80000	0x20000	IPL
0xA0000	0x20000	EBTCFG
0xC0000	0x60000	LOGO
0x120000	——	MBR

block5	LOGO	128KB
block4	IPL	128KB
block3	EBOOT	128KB
block2	EBOOT	128KB
block1	OBM	128KB
block0	NTIM	128KB