Posts on H⁺ + OH⁻ → H₂O

自建 Immich 相册服务同步白嫖 Google Photos

Sat, 15 Jun 2024 00:00:00 +0000

Google Photos 有着 15GB 的免费空间上限，前几个月自己搞了 NAS 之后，看上了 Immich 相册，算是最贴近 Google Photos 界面的开源自建相册服务了，自己手头也正好还留着当初买的初代 Google Pixel，能够以原画质白嫖无限相册空间，相当于能够在本地备份的同时也拥有稳定的云备份。

考虑到稳定性，NAS 上并没有安装 APP 或者其他容器服务，单纯作为一个存储设备。Docker 服务都放在另一台小主机上运行。

计划是 TrueNAS 存储只提供 SMB 服务挂载，小主机上通过多个 Docker 分别部署 Immich 相册，以及用来同步照片到 Pixel 的 Syncthing 服务。另外手机肯定是7*24供电的状态，为了不用频繁物理操作，考虑部署 RustDesk 服务远程控制手机，同样采用 Docker 的方式部署在小主机上。

软硬件配置

TrueNAS 服务器 CPU 是 N100， 16GB 内存， 16TB*2 HDD（Raid 1）

小主机 CPU 同样是 N100，24GB 内存，256GB SSD，Debian 系统

初代 Pixel，未 Root

TrueNAS 配置

非常简单，TrueNAS 上的配置就结束了，继续配置小主机。

服务器配置

首先为了让之后 Immich 从 NAS 上读写，需要把 SMB 开机自动挂载路径。SSH 登陆后执行：

sudo apt install cifs-utils psmisc
nano ~/.credentials

对应修改 SMB 共享的用户名和密码

username=smbusername
password=smbpassword

sudo chown username .credentials
sudo chmod 600 .credentials

测试挂载

sudo mkdir /mnt/Immich
sudo mount -t cifs -o credentials=~/.credentials //truenas.ipaddress/Immich /mnt/Immich

没有问题则暂时卸载

sudo umount -t cifs /mnt/Immich

修改 /etc/fstab

sudo nano /etc/fstab

添加如下内容

# Immich Storage
//truenas.ipaddress/Immich /mnt/Immich cifs credentials=/home/username/.credentials 0 0

应用修改完成挂载

sudo systemctl daemon-reload
sudo mount -av

Docker 配置

安装 Docker

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

echo \
 "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
 $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
 sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

部署 Immich

官方推荐采用 Docker Compose 的方式安装，跟着教程走并没有什么难度。

mkdir ~/immich-app
cd ~/immich-app

wget -O docker-compose.yml https://github.com/immich-app/immich/releases/latest/download/docker-compose.yml
wget -O .env https://github.com/immich-app/immich/releases/latest/download/example.env
wget -O hwaccel.transcoding.yml https://github.com/immich-app/immich/releases/latest/download/hwaccel.transcoding.yml
wget -O hwaccel.ml.yml https://github.com/immich-app/immich/releases/latest/download/hwaccel.ml.yml

编辑 .env 文件，修改照片的上传路径

TZ=Asis/Shanghai
UPLOAD_LOCATION=/mnt/Immich
DB_DATA_LOCATION=./postgres

数据库路径不变，之所以这样是因为数据库有频繁的读写，像 16T 容量的机械盘基本都是充气盘，会频繁的发出炒豆子的声音。
换言之只要不是充气盘或者距离远听不见声音就无所谓了，可以改成 /mnt/Immich/postgres

docker compose up -d

启动容器后，访问 http://server.ipaddress:2283/ 登录，在设置/机器学习设置/智能搜索/CLIP模型，修改为支持多语言的XLM-Roberta-Large-Vit-B-16Plus。

为了便于管理，启用设置/存储模板功能。

在设置/视频转码设置中，支持的音频编解码器勾选 AAC/MP3/Opus，支持的视频编解码器勾选 H.264/HEVC/VP9/AV1，因为我现在的主力机都支持这些编码，没有必要转码。

部署 Syncthing

先建立需要的目录

sudo mkdir -p /var/syncthing/Immich
mkdir ~/syncthing
cd ~/syncthing
nano docker-compose.yml

按照官方指导编写 Dockerfile

docker-compose.yml

---
services:
 syncthing:
 image: syncthing/syncthing
 container_name: syncthing
 hostname: Dorothy
 environment:
 - PUID=1000
 - PGID=1000
 volumes:
 - /var/syncthing:/var/syncthing
 - /mnt/Immich/library/admin:/var/syncthing/Immich
 network_mode: host
 restart: unless-stopped

docker compose up -d

启动容器后，访问 http://server.ipaddress:8384/ 登录，添加文件夹

在高级书签中选择文件夹类型为仅发送

这样 Syncthing 的初步配置就结束了

部署 RustDesk

同样按照官方指导建立 Dockerfile

docker-compose.yml

---
services:
 hbbs:
 container_name: hbbs
 image: rustdesk/rustdesk-server:latest
 command: hbbs
 volumes:
 - ./data:/root
 network_mode: "host"

 depends_on:
 - hbbr
 restart: always

 hbbr:
 container_name: hbbr
 image: rustdesk/rustdesk-server:latest
 command: hbbr
 volumes:
 - ./data:/root
 network_mode: "host"
 restart: always

启动服务

docker compose up -d

获取服务端 API KEY

docker container logs hbbs | grep Key

配置 Pixel 自动任务

首先安装 Syncthing 和 RustDesk 的客户端

然后是用来实现自动任务的 Tasker 和 TouchTask

连接 RustDesk

修改对应的服务器 IP 地址和 KEY

允许 IP 地址访问，保持后台服务，允许自启动

设置固定密码，使用固定密码

勾选全部权限后启动服务

在自己的主机上也装好 Rustdesk，修改对应的服务器 IP 地址和 KEY 信息后，现在就可以接上充电线放在一边，通过电脑远程操作 Pixel 了。

连接 Syncthing

选择 Syncthing 的设备然后点击右上角+，添加设备

回到 http://server.ipaddress:8384/ 登录，点击识别的设备标识，通过手机扫码或者直接输入完整设备标识字符串进行配对

然后网页端会出现配对许可的提示，同意即可。

接着编辑之前共享的目录，共享给配对的设备。

回到手机，同意接收共享，将目录选为照相机的默认目录 /storage/emulated/0/DCIM/Camera，目录种类更改为仅接收。

这样就实现了 Immich 从 NAS 往 Pixel 的单向同步，之后在 Pixel 上清除本地缓存时也不会导致 NAS 上的文件被同步删除，Pixel 也会自动将同步收到的照片上传至 Google Photos。

配置 Tasker

为了避免手机存储满了之后无法继续同步文件，需要定期运行相册 APP 释放空间，这里就可以使用 Tasker 来完成。

主要的操作一共三种：

+/任务/等待
+/程序/启动应用/结束应用
+/插件/TouchTask/Actions

屏幕点击操作需要的坐标数据可以通过打开开发者选项/输入/指针位置来获取

然后按照

等待/结束相册/启动相册/等待/点击头像/释放空间/确定释放/等待/启动Tasker（回前台）

的逻辑添加操作步骤即可

之后添加配置文件，让任务定时执行

FakeStandby

为了不需要 Root 权限，Pixel 设置了不锁屏，但保持亮屏一是容易造成烧屏，二是造成无意义的耗电，为此可以安装 FakeStandby 这款应用，通过显示黑屏实现伪锁屏待机。

导入 Google Photos

最后，对于已经在 Google 相册中的照片，可以通过 Google 导出服务和 immich-go 工具便捷的导入 Immich。

访问 https://takeout.google.com/settings/takeout/custom/photos

在要包含的数据中选择 Google 相册，继续，然后再目标位置选择添加到 OneDrive，文件类型选择.zip，大小选择50GB。

视具体网络情况，选择通过 OneDrive 可以直连下载，节约大量的代理流量。

网页端登录 Immich，点击头像/账号设定/API Keys/新API Key，复制下 Key 字符串。

Google 导出结束后，下载immich-go，将解压的 exe 文件和 Google 导出的 zip 放在同一目录中，打开命令行 cd 到此目录并执行

.\immich-go.exe -server=http://immich.ipaddress:2283 -key=API_KEY_STRING upload -google-photos takeout-*.zip

即可将过去的相册内容导入至 Immich。

EOF

Google 目前的政策只有初代 Pixel 能够上传原始画质享有无限空间，后代的 Pixel 也只有最早的几代能够上传省空间画质且享有无限空间。

目前闲鱼 2~300 收一个初代 Pixel 还是合算的，不过哪天 Pixel 电池顶不住了，是换电池还是换机，亦或者直接抛弃 Google 相册，就见仁见智了。

树莓派搭建网络摄像头

Fri, 15 Mar 2024 00:00:00 +0000

年前迭代了 3D 打印机，换了拓竹的 A1 mini。感慨技术迭代是真的快，Ender 3 真的是完全落后时代了，打算（已经）拆了改造成 PET 回收装置。

对应着原本担当远程控制作用的树莓派又双叒叕闲置了，再次折腾点东西玩。

树莓派是 Raspberry Pi 3B+ ，现在已经算是老东西了。摄像头放弃了专用的排线摄像头，排线的物理距离太短还容易伤，换了另一个闲置的 USB 摄像头，型号是 Logitech C920。

主要参考了 Setting up HLS live streaming server using NGINX 的设置过程。

配置过程

安装软件包

sudo apt-get update
sudo apt install nginx libnginx-mod-rtmp ffmpeg

nginx 配置

sudo nano /etc/nginx/nginx.conf

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;
events {
worker_connections 1024;
}
rtmp {
server {
listen 1935;
chunk_size 4000;
application show {
live on;
hls on;
hls_path /tmp/hls/;
hls_fragment 3;
hls_playlist_length 60;
}
}
}
http {
sendfile off;
tcp_nopush on;
directio 512;
default_type application/octet-stream;
server {
listen 8080;
location / {
add_header 'Cache-Control' 'no-cache';
add_header 'Access-Control-Allow-Origin' '*' always;
add_header 'Access-Control-Expose-Headers' 'Content-Length';
if ($request_method = 'OPTIONS') {
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Max-Age' 1728000;
add_header 'Content-Type' 'text/plain charset=UTF-8';
add_header 'Content-Length' 0;
return 204;
}
types {
application/dash+xml mpd;
application/vnd.apple.mpegurl m3u8;
video/mp2t ts;
}
root /tmp/;
}
}
server {
listen 80;
location / {
root /var/www/html/;
}
}
}

sudo systemctl enable nginx
sudo nginx -t
sudo nginx -s reload

ffmpeg 推流配置

sudo nano /etc/systemd/system/ffmpeg_stream.service

[Unit]
Description=FFmpeg Streamer
After=network.target
[Service]
ExecStart=/bin/bash -c 'while true; do ffmpeg -hide_banner -thread_queue_size 512 -s 1280x720 -i /dev/video0 -thread_queue_size 1024 -f lavfi -i anullsrc -codec:v h264_v4l2m2m -b:v 8096k -c:a aac -b:a 128k -r 24 -f flv rtmp://localhost/show/stream || continue; done'
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo service ffmpeg_stream enable
sudo service ffmpeg_stream start

html 播放器页面

sudo nano /var/www/html/index.html

<!DOCTYPE html>
<html lang="en">

<head>
 <meta charset="UTF-8">
 <title>Live Streaming</title>
 <link href="//vjs.zencdn.net/8.3.0/video-js.min.css" rel="stylesheet">
 <script src="//vjs.zencdn.net/8.3.0/video.min.js"></script>
</head>

<body>
 <div style="margin: auto;width: 100%;padding: 0px;">
 <video id="my-player" class="video-js vjs-default-skin" controls preload="auto" poster="poster.jpg"
 data-setup='{"fluid": true}'>
 <source src="http://raspberry.home:8080/hls/stream.m3u8" type="application/x-mpegURL">
 </source>
 <p class="vjs-no-js">
 To view this video please enable JavaScript, and consider upgrading to a
 web browser that
 <a href="https://videojs.com/html5-video-support/" target="_blank">
 supports HTML5 video
 </a>
 </p>
 </video>
 </div>
 <script>
 var player = videojs('my-player');
 </script>
</body>

</html>

EOF

至此摄像头架设完成。

Git 检测到存储库可能不安全的解决方法

Tue, 12 Mar 2024 00:00:00 +0000

因为经常折腾东西导致重新安装系统，也因此经常遇到类似如下问题：

git status

fatal: detected dubious ownership in repository at 'D:/Neutralization.github.io'
'D:/Neutralization.github.io/.git' is owned by:
 (inconvertible) (S-1-5-21-111-111-111-1001)
but the current user is:
 WORKGROUP/Neutralized (S-1-5-21-222-222-222-1002)
To add an exception for this directory, call:

 git config --global --add safe.directory D:/Neutralization.github.io

网上的建议一般是按照 git 的提示照做添加 safe.directory ，或者就是文件夹右键属性/安全/高级/更改所有者/☑替换子容器和对象的所有者这样的一套操作。

其实完全可以简化为：

sudo takeown /R /F .
sudo icacls . /reset /q /t /c

留作记录。

OpenWrt 使用 WireGuard 组网及局域网文件共享设置

Tue, 12 Dec 2023 00:00:00 +0000

一直以来都是依靠群友/同事的帮助来配置当甩手掌柜，最近路由升级 OpenClash 又炸了，加上之前神秘的 DNS 转发失败的问题，决定从零开始自己重新配置一遍软路由，实践出真知。

前期准备

硬件上用的是两台 FriendlyARM NanoPi R2S，闲鱼现在 200 出头就可以收到，主要是体积小巧，本来的需求也只是跑个 OpenWrt + WireGuard 组网，性能完全够用。家里的网络也没有千兆，不担心跑不满带宽的问题。

因为是要打算跟公司里的设备组网，显然公司是不会给你 IP / 端口转发的，所以家里的宽带需要申请公网 IP + 桥接。之前买了台小米的 Redmi AX6S 用作家里的软路由，但刷机不如 R2S 方便，就刷回原厂用作 AP 了。

考虑到公网 IP 拨号可能重新分配，最好还是绑定个域名做 DDNS，便于之后 WireGuard 通信，避免意外断电重启找不到 IP。

OpenWrt 配置

因为 R2S 已经在 OpenWrt 的支持列表里了，这里简单从官网下一个镜像，目前的版本是 23.05.2。

镜像选择了 SQUASHFS 格式，主要是为了方便重置配置备份升级。但缺点是默认的分区大小可能有些局促，需要进行一下扩容。

刷写完毕启动后，SSH 进入 OpenWrt，执行以下命令：

# 更换为国内镜像源加快下载
sed -i 's/downloads.openwrt.org/mirrors.ustc.edu.cn\/openwrt/g' /etc/opkg/distfeeds.conf
opkg update
opkg install cfdisk losetup f2fs-tools

# https://github.com/anaelorlinski/OpenWrt-NanoPi-R2S-R4S-Builds/blob/main/docs/resize-f2fs.md
cfdisk /dev/mmcblk0
# 选择第二个分区，扩容，写入，退出
LOOP="$(losetup -n -O NAME | sort | sed -n -e "1p")"
ROOT="$(losetup -n -O BACK-FILE ${LOOP} | sed -e "s|^|/dev|")"
OFFS="$(losetup -n -O OFFSET ${LOOP})"
LOOP="$(losetup -f)"
losetup -o ${OFFS} ${LOOP} ${ROOT}
fsck.f2fs -f ${LOOP}
mount ${LOOP} /mnt
umount ${LOOP}
resize.f2fs ${LOOP}
reboot

重启后扩容完成，可以继续 opkg install 需要的包了。

# 因为还是有后期加上 OpenClash 的打算，先替换 dnsmasq
opkg remove dnsmasq && opkg install dnsmasq-full

# OpenClash 的依赖包
opkg install coreutils-nohup bash curl ca-certificates ipset ip-full libcap libcap-bin ruby ruby-yaml kmod-tun kmod-inet-diag unzip kmod-nft-tproxy luci-compat luci luci-base

# WireGuard + 自己需要的包
opkg install luci-app-wireguard nano-full bind-dig

两边的 OpenWrt 要分配不同的网段，访问 OpenWrt 页面（默认地址 192.168.1.1）：

Network -> Interfaces -> Lan -> Edit -> IPv4 address

这里举例家里设备为 192.168.10.1/24 公司为 192.168.20.1/24。

WireGuard

前述已经安装好了 WireGuard，配置时最好能够同时访问两台设备，操作都是相同的。

添加新接口

Network -> Interfaces -> Add new interface…

Name: WireGuard
Protocol: WireGuard VPN

设置新接口

Network -> Interfaces -> WireGuard -> Edit -> General Settings

Listen Port: 50251
IP Addresses: 192.168.192.10

这里的 IP 地址是 WireGuard 识别自身设备的地址，给两个设备设置在同一个子网 (192.168.192.0) 里就行，比如另一台设备设置为 192.168.192.20，末位数和 LAN 的地址数字相同便于自己识别。

点击 Generate new key pair，复制生成的 Public Key 记录下来，之后要用。

转到 Firewall Settings，选择 LAN。

然后再转到 Peers 点击 Add peer 添加对端设备。

在 192.168.10.1 上配置

Public Key: 192.168.20.1 的 `Public Key`
Allowed IPs: 192.168.192.20/24, 192.168.20.1/24
Route Allowed IPs: ☑
Endpoint Host: 留空
Endpoint Port: 留空
Persistent Keep Alive: 25

在 192.168.20.1 上配置

Public Key: 192.168.10.1 的 `Public Key`
Allowed IPs: 192.168.192.10/24, 192.168.10.1/24
Route Allowed IPs: ☑
Endpoint Host: ddns.router.home（绑定了公网 IP 的 DDNS 域名）
Endpoint Port: 50251
Persistent Keep Alive: 25

两边配置完成后重启 WireGuard 接口，如无意外应该能看到握手数据，互相 ping 对面设备的 LAN 地址，正常返回数据则 WireGuard 已经正常工作。

最后配置 watchdog，意外断电重启公网 IP 变动后 WireGuard 可以及时重新连接：

echo ‘* * * * * /usr/bin/wireguard_watchdog’ » /etc/crontabs/root

允许 WireGuard 通过防火墙

Network -> Firewall -> Traffic Rules -> Add

Name: Allow-WireGuard
Protocol: UDP
Source zone: WAN
Destination zone: Device (input)
Destination port: 50251
Action: accept

配置 DNS 解析和转发

有了 WireGuard 后最方便的事情就是可以在家访问公司内网服务，只要通过位于内网路由的 DNS 来解析内网地址就行。

在内网也可以访问家里的设备，两边设置不同的域即可，对应的域转发给对应的 DNS 来解析。

Network -> DHCP and DNS -> General Settings

在 192.168.10.1 上配置

Local server: /home/
Local domain: home
DNS forwardings: /office/192.168.192.20
Rebind protection: ☐

在 192.168.20.1 上配置

Local server: /office/
Local domain: office
DNS forwardings: /home/192.168.192.10
Rebind protection: ☐

需要在家里（192.168.10.1）访问内网时，按两步走：

将对应的内网域名以 /abc.xyz/192.168.192.20 的格式添加到 DNS forwardings 中
将对应的解析 IP/IP段添加到对端 Peer 的 Allowed IPs 中
也可以直接将内网 DNS 地址添加到 Allowed IPs 中，1 中的 LAN IP 直接换成内网 DNS 地址。

这样就能用正确的 DNS 结果（通过 WireGuard 转发给公司上游 DNS 解析），访问到内网 IP 上的服务。

通过 dig 命令可以查看是否正确转发了 DNS 请求。

设置完成后可以通过 hostname.domain (比如 raspberry.office, router.home) 的方式访问两边的设备，不用再记难记的 IP 地址了。

主机防火墙策略

通过上述方式建立了局域网之后，理所应当就可以在局域网里共享文件进行传输了，由于两边子网不同，需要一些简单的设置。

首先打开当前连接网络的网络配置文件，看一下网络状态是公用还是专用网络。然后打开：

Windows 10：控制面板\网络和 Internet\网络和共享中心\高级共享设置
Windows 11：设置\网络和 Internet\高级网络设置\高级共享设置

在对应的配置文件里启用网络发现和文件和打印机共享，在所有网络的配置文件里启用有密码保护的共享。

打开防火墙设置：

Windows 10：控制面板\系统和安全\Windows Defender 防火墙\高级设置
Windows 11：设置\网络和 Internet\高级网络设置\Windows 防火墙\高级设置

在入站规则中找到文件和打印机共享(SMB-In)（有多个，选择对应网络配置的那一个），双击打开属性，选择作用域，在远程IP地址处选择任何IP地址，或者添加对应子网，比如访问家里设备的共享，就添加公司的子网地址192.168.20.0/24。

局域网文件传输

上述设置完成后，比如我们在家里电脑上共享一个文件夹Share：

\\computer.home\Share

我就可以直接通过这个网络地址打开共享，输入账号密码认证后像本地文件夹一样传输文件了。

至此，我终于不用受限于公司 VPN 的各种问题，也不需要靠 WSL 做桥梁，用最习惯的方式同步文件了。

而且此前设置的 OpenSSH 也能互相正常访问，爽到。

一些额外的折腾

完全是为了用 robocopy 而用 robocopy 的折腾，记录一下。

原因还是 SCP 不够灵活，想要类似 rsync 的体验。其实就是需要一个差异同步的功能减少传输数据量节约时间，结果还得是 robocopy，而且 robocopy 支持形如 \\computer.home\Share 的网络地址，完美。

考虑到 robocopy 的 /compass 参数需要条件支持，批量小文件传输速度本身也会比较慢，而后者的影响比较大，打算利用 robocopy 导出差异列表，然后打包小文件变成一个大文件来传输提高效率。

RoboCopy [source] [dist] . /E /Z /COPY:DAT /DCOPY:T /XD __pycache__ node_modules venv .git .github /XO /IT /XJ /R:3 /W:3 /REG /NC /NS /NDL /NJH /NJS /LOG:diff.txt

7z a -t7z diff.7z -i@“diff.txt” -scsWIN -spf

EOF

这下折腾爽了。

给 OpenWrt 加上 DDNS

Tue, 06 Jun 2023 00:00:00 +0000

给家里的宽带申请了公网 IP，为了方便连回家绑了自己的一个域名。虽说一般也不会关掉路由器，为防万一还是简单做个 DDNS 确保 IP 地址能更新。

因为用的是主机壳的域名解析服务，先从后台拿到 API 密钥。

然后去域名解析管理添加一条新的 A 记录，指向家里路由的公网 IP 地址。

简单写个 bash 脚本，搞定。

domain="example.com"
header="router" # router.example.com <-> public ip address
email="*************************"
token="*************************"
trueip=$(ifconfig pppoe-wan | grep -Eo 'inet (addr:)?([0-9]*\.){3}[0-9]*' | grep -Eo '([0-9]*\.){3}[0-9]*' | grep -v '127.0.0.1')
echo "${trueip}"

if [[ "${trueip}" = $(cat /root/ip) ]]; then
 echo "pass"
else
 getRecord="{\"action\": \"DomainDNS.getRecords\", \"domain\": \"${domain}\"}"
 echo "${getRecord}"
 sign=$(echo -n "${getRecord}" | openssl sha256 -hmac "${token}" | sed 's/^.* //')
 echo "${sign}"
 curl -sL -X POST "https://api.hostker.net/v2" -H 'Content-Type: application/json' -H "Sign: ${sign}" -H "Email: ${email}" -d "${getRecord}" -o records.json

 recordip=$(jq -r '.result.records[] | select(.header=="'$header'").value' records.json)
 echo "${recordip}"
 if [[ "${trueip}" = "${recordip}" ]]; then
 echo "${recordip}" > /root/ip
 else
 old_record=$(jq -c -r ".result.records[] | select(.header==\"${header}\")" records.json)
 echo "${old_record}"
 new_record="{\"type\":\"A\",\"ttl\":600,\"header\":\"${header}\",\"value\":\"${trueip}\"}"
 echo "${new_record}"

 upRecord="{\"action\": \"DomainDNS.updateRecord\", \"domain\": \"${domain}\", \"old_record\": ${old_record}, \"new_record\": ${new_record}}"
 echo "${upRecord}"
 sign=$(echo -n "${upRecord}" | openssl sha256 -hmac "${token}" | sed 's/^.* //')
 echo "${sign}"
 curl -sL -X POST "https://api.hostker.net/v2" -H 'Content-Type: application/json' -H "Sign: ${sign}" -H "Email: ${email}" -d "${upRecord}" -o resp.json
 fi
fi

接着去 OpenWrt 添加一条计划任务：

opkg update
opkg install openssl-util jq
chmod +x /root/hostker_ddns.sh
crontab -e

*/5 * * * * /root/hostker_ddns.sh

记录一些和 Unicode 不断作斗争的日子

Tue, 09 Aug 2022 00:00:00 +0000

最开始给哔哩哔哩周刊写自动化脚本的时候，还不觉得生成图片能遇到什么坑。毕竟之前也用过 Pillow 库，算是比较熟悉了。而且遇到的都是些在普通不过的正常文本。

直到躲不开的 emoji 开始出现了。

一些普通的 Emoji

☀☁☂☃☄☎☑☔☕☘

刚开始遇到这类也还好，因为很显然，只是文本的字体没有这部分 emoji，Pillow 就全部给显示成了方框。简单框了个范围，用另一个字体来渲染就是了。

但后来就开始遇到各种标题里的花活，什么上下标字符花体字粗斜体全来了。比如

【𝟒𝐊 𝟔𝟎𝐅𝐏𝐒】这首《𝑭𝒂𝒍𝒍𝒊𝒏𝒈 𝑨𝒈𝒂𝒊𝒏》如今治愈了多少人！！! ℳ₯㎕-沉沦

自此真正打响了与 Unicode 斗争的第一枪。

一些普通的 Unicode

上下标字符花体字粗斜体也能接受，人家看起来至少还是个正经字符。解决方法也是一样的简单粗暴：找一个定义了这部分字符的字体，单独匹配渲染。

于是脚本里的 UnicodeA_F 慢慢增加到了 UnicodeD_F。划一个新的正则范围，匹配上一个新的字体，如此查漏补缺的工作也还能接受，毕竟遇到特殊字符的场合相对还是非常有限的。

直到真正的重量级上场了。

Combining 字符

✥我҉͛̀̈̈̾̓̀͂̊͝的模҉̖̭̱͍̩͕͓̋̓͋̈̑͋̉͢͞ͅ样吓҈̎̍̅̒̎͂̈́̚͞.到你҈̛́̐̄́̃͗̓͒͒͊̿͛̒了？～❤✥

只能承认它杀死了比赛。但其实类似的标题并不是第一次见，在更早之前，我算是见过它的一位大前辈：

这位前辈更是重量级，即便在写这篇记录的时候，我也不得不佩服这种和视频契合的标题风格确实是非常到位。

能做到这种效果的原因是由于其中大量的 Combining 字符，比如日文的清浊音符号，部分小语种的音标和一些独特的组词方式。

但是 Pillow 罢工了呀，臣妾渲染不来，您还是另请高明吧。

思来想去不得法，最后想到，那既然网页前端能够正常展示，应该可以通过无头浏览器前端渲染然后截屏的方式，把这些特殊字符正确的显示出来。

简单糊了个页面，算是解决了这个问题。哔哩哔哩周刊与 Unicode 的斗争也算是告一段落了。

MAD 周刊，新的挑战

接手开始MAD 周刊的自动化后，很快又不得不面对 Unicode 带来的问题。然而实际上，应该说是 Unicode 和 Adobe 共同带来的问题。

为了保证原始 MAD 周刊工程文件的纯洁性，所有的文本都按照文本图层来进行修改。本来这也没有什么问题。

但是原工程使用的大量表达式，是基于旧版的 ExtendScript 引擎，毕竟工程本身是 2016 年的产物。但之前做哔哩哔哩周刊时一直用的是 JavaScript 引擎的表达式，这就产生了几个问题：

特殊的 Unicode 字符需要使用不同的字体才能正常显示
ExtendScript 不能修改文本图层的部分字体样式属性
相比 ExtendScript，JavaScript 能够修改字体字号颜色等属性
为了使用 JavaScript 引擎就要把整个工程的其他表达式全部重写
AfterEffects 对通过脚本修改字体的行为有奇怪的问题，不能保证正常显示

由于工作量太大，重写全部表达式显然不现实。基于此，我选择了另一种方式：让所有花活都变成正常的字符。

这就需要有一个表来记录这些特殊字符应该被替换为具体哪一个字符，于是诞生了 Antimemetics-Division 这样一个对抗项目。

期间则是枯燥的 Unicode 查表浏览过程，尽可能多的搜集这类特殊字符的标题来保证更广的覆盖面。

而后 Emoji 的问题也需要处理，这就要划分 Emoji 的 Unicode 字符范围。幸好这部分有据可查，在 Unicode 官方规范中有详细的记录各个 Emoji。

Combining 字符的问题也得到了解决，Unicode 官方规范中规定了 Mc Me Mn 三类 Mark 字符正好能够覆盖这个问题。

最终 Antimemetics-Division 不负使命，让 MAD 周刊中的标题都成为了“正经标题”，可喜可贺，可喜可贺。

~~虽然留下了反向利用此项目可以生成更加让人血压爆炸的标题的问题，暂且不提~~

本可以更优雅的解决方式

如是几期视频更新后，我逐渐意识到一种割裂感。

为什么哔哩哔哩周刊就应该渲染正常，MAD 周刊就要去掉这些字符呢？这种区别对待说白了，不过还是一种懒惰。

不同于我最初承认 ATOLS 玩的一手好标题，在 MAD 周刊上我反而以字符论标题优劣，不应是正确的解法。

于是决定同哔哩哔哩周刊一样通过前端截图来解决这个问题。同时考虑到排版影响，部分 MAD 标题常用全角符号，导致标题的起始像素位置其实并不顶格，便在脚本中加入了一个粗略的判断，进行一个 X 轴的移位使得视觉上显得更对齐一些。

但 Emoji 还是给我捣了乱，Emoji 因为都是全角宽度，无法判断像素位置是否顶格，这个问题只能留到之后再寻找合适的解法了。

Update 2022/10/03

成了，生成图片然后切左右透明像素就是了，问题解决（

未尽之事

计划将哔哩哔哩周刊的图片生成也改为前端截图的方式。且不谈特殊字符的问题，前端这种方便可视化调整的形式，应该会对代码修改更友好一些，虽然想来是不会有什么改版和修改了。

而且通过 CSS，还能够实现一些 Pillow 做不到的文本样式效果，更好的还原 PSD 的设计样式。

曾经还想过写 Photoshop 脚本来做图，虽然还没试验过 Photoshop，考虑到前述 AfterEffects 文本图层的问题，以及前端截图确实更灵活，也就不再考虑了。

OpenWrt 折腾笔记

Tue, 05 Oct 2021 00:00:00 +0000

准备工作

安装 WSL，不再赘述。
移除 WSL 环境变量中包含的 Windows 路径，为编译做准备。

打开 WSL 终端，新建/etc/wsl.conf文件，输入如下内容并保存。
```
[interop]
appendWindowsPath = false
```
然后执行wsl --shutdown，再重新启动 wsl，执行echo ${PATH}检查是否含有 Windows 路径。
更新系统

sudo apt update
sudo apt full-upgrade -y
准备编译工具

sudo apt install -y ack antlr3 asciidoc autoconf automake \
autopoint binutils bison build-essential bzip2 ccache cmake cpio \
curl device-tree-compiler fastjar flex gawk gettext gcc-multilib \
g++-multilib git gperf haveged help2man intltool libc6-dev-i386 \
libelf-dev libglib2.0-dev libgmp3-dev libltdl-dev libmpc-dev libmpfr-dev \
libncurses5-dev libncursesw5-dev libreadline-dev libssl-dev libtool \
lrzsz mkisofs msmtp nano ninja-build p7zip p7zip-full patch pkgconf \
python2.7 python3 python3-pip qemu-utils rsync scons squashfs-tools \
subversion swig texinfo uglifyjs upx-ucl unzip vim wget xmlto xxd zlib1g-dev

克隆仓库

下载 OpenWrt 源码（更改为LEDE）

cd ~
git clone https://github.com/coolsnowwolf/lede openwrt
cd openwrt
git pull

下载 OpenClash 源码

cd ~/openwrt/
mkdir package/luci-app-openclash
cd package/luci-app-openclash
git init
git remote add origin https://github.com/vernesong/OpenClash.git
git config core.sparsecheckout true
echo "luci-app-openclash" >> .git/info/sparse-checkout
git pull --depth 1 origin master
git branch --set-upstream-to=origin/master master

修改路由 IP 地址

> sed -i 's/192.168.1.1/192.168.2.1/g' package/base-files/files/bin/config_generate

开始编译

更新 feeds

cd ~/openwrt/
./scripts/feeds update -a
./scripts/feeds install -a

选择编译内容

cd ~/openwrt/
make defconfig
make menuconfig
./scripts/diffconfig.sh > diffconfig

diffconfig 后期可用于更新镜像时导入

cp diffconfig ~/openwrt/.config
make defconfig
make menuconfig

Target System --->
(X) Rockchip
Subtarget --->
(X) RK33xx boards (64 bit)
Target Profile --->
(X) FriendlyARM NanoPi R2S
Target Images --->
[*] ext4
[*] squashfs
[*] GZip images
(128) Kernel partition size (in MB)
(2048) Root filesystem partition size (in MB)
Kernel modules --->
Cryptographic API modules --->
ALL
LuCI --->
2. Modules --->
Translations --->
<*> Simplified Chinese (zh-cn)
<*> luci-compat
3. Applications --->
<*> luci-app-openclash
<*> luci-app-turboacc
<*> luci-app-unblockmusic
[*] UnblockNeteaseMusic NodeJS Version
<*> luci-app-wireguard
<*> luci-app-zerotier
4. Themes --->
<*> luci-theme-argon
Utilities --->
Editors --->
<*> nano-full

执行编译

cd ~/openwrt/
make -j8 download
make -j8

编译生成的镜像文件在 ~/openwrt/bin/targets/rockchip/armv8/ 路径下

收尾工作

opkg 安装部分官方包的时候会提示 Kernel 版本不对kernel is not compatible，这是因为自己编译的 kernel 指纹和官方不一致造成的，替换成官方指纹即可。

比如目前 kernel 版本是5.4.143-1-fb881fbbae69f30da18e7c6eb01310c1

sed -i s/编译的kernel hash/fb881fbbae69f30da18e7c6eb01310c1/g /usr/lib/opkg/status

EOF

编译 run 了一万年，再不写点什么记下来，下次编译根本记不住了.jpg

后来参考学习了 P3TERX 的这篇文章利用 Github Action 进行编译，并且按照 LEDE 的这个 PR 打开了缓存工具链，再也不用面对奇怪的环境问题和该参数重编又是四、五个小时的窘境了。

升级 3D 打印机固件及远程打印方案

Sat, 28 Aug 2021 00:00:00 +0000

Ender 3 不愧是创想三维家的经典款 3D 打印机，一直没关注产品消息，不知道什么时候已经出了 V2 款了。

买当然是不会买的，原来的版本还是挺好用，购买的时候正好京东打折，当时 1k 出头的价格还是很香的。

买来时间也有点久了，考虑升级一下固件，但是官方并没有提供这一款的后续固件升级，也没有相关教程。搜索了一下发现还需要自行刷入 bootloader 后才能刷写固件，看来是当时就没有考虑用户侧的后续升级。

升级固件的想法主要是因为看到了 OctoPrint，一个利用树莓派控制和实时监控 3D 打印机的项目。

刷写 bootloader

主要是跟着Bootloader Flashing Guide这篇文章中的指导。因为主板芯片是 1284P，和其他打印机的刷写存在区别，建议直接下载链接中的刷写包来操作。

概括的来讲，需要 Arduino 开发板作为中介，与打印机主板的刷写接口连接，再通过 Arduino IDE 将 bootloader 引导程序由 Arduino 刷写到打印机主板芯片上。

找同事借了一块 Arduino MEGA 2560 和几根杜邦线，因为 Arduino 的不同版本引脚定义几乎没有区别，也不是一定要用 Arduino Uno。

完成这一步后，打印机有了 bootloader，就可以方便的进行固件升级操作了。

编译固件并上传至打印机

TH3D 给出了 Ender 3 的完整固件升级流程。

真的是个不错的网站，除了 Creality 还有其他很多常见 3D 打印机厂家不同型号的操作教程。根据教程描述，安装 VSCode，编译固件上传即可，实际操作中我也完全没有遇到阻碍，非常顺利的编译上传完成了，见到了启动画面的 TH3D 标志 logo。除了界面是全英文，但这也并不影响机上操作。

OctoPrint 远程打印

又是一个利用树莓派的项目，于是我的树莓派又经历了一次 SD 卡格式化重写映像。

同样也是完全跟随教程操作，在树莓派上使用 OctoPrint 映像，连接 WiFi，USB 连接打印机。

教程中还提供了一套用于固定树莓派摄像机的 3D 打印文件，可以固定在打印机 X 轴上用来监测打印状态。也可以选择使用普通的 USB 摄像头，但是架设摄像头的方式就要靠自己另外实现了。

正好很早以前买过一个树莓派专用摄像头，这就给它用上了。

Finish

一切设置好，https 访问树莓派 IP 或者 https://octopi.local/ ，如果摄像头正常的话，就能看到打印状态了。

界面里可以一览无余的看到打印机当前的喷嘴和热床温度，打印状态，Gcode 图示等等。也可以直接通过网页上传 Gcode 文件直接打印，由于是通过 USB 连接到打印机，免去了反复插拔 SD 卡传输文件的步骤，真的是方便了很多。

OctoPrint 还提供视频录制，开启后可以录制打印过程中的摄像头画面，生成延时视频。

圆周率里的麻将

Wed, 17 Mar 2021 00:00:00 +0000

2 月的时候，群友看 VTB 直播雀魂，发现主播为了防止互动的时候窥屏看到手牌，PS 了一张看起来像手牌的图来挡住真实的手牌。

群友受此启发，纷纷讨论自己也要这么玩，PS 各种役种的牌扮老虎，比如大家都喜欢的国士无双：

大家云集响应，因为之前正好写过生成器，趁此机会我就说群友要啥我就帮群友 PS，都可以做。后来群友觉得正经的役没意思，想搞点不一样的，说要搞个圆周率。这就有意思了。话题很自然的转到了那能不能胡牌的问题上，因为只有数字，先默认牌型是清一色，一试，发现小数点后最开始的 14 位数字就真的能凑成一副胡牌：

3.14159265358979 -> 234 678 555 999 11

我立刻兴致来了，马上就想看看位数再往后，还能有哪里能凑成胡牌，这就开始写脚本。

圆周率位数的迭代之前写飞花令的时候用过，Ctrl+V 过来，然后是判断是否和牌的算法。简单来说按照一般和牌的标准型n*AAA+m*ABC+DD=14，通过先取雀头DD，然后交换先取刻子AAA后顺子ABC或者先顺子后刻子的逻辑迭代完整副手牌，看残张是否为零就能确认这副手牌是否和牌。

写完代码，测试了几次，又另外加入了七对子牌型的判断，然后以一万位为目标执行了一遍。不出意料还真的有很多位置的数列能够凑成和牌。感觉这还是值得做个视频记录一下。

视频里只迭代了小数点后一万位的数字。在测试脚本的时候，其实试验过迭代到二十万位，已经相当耗时了，不过也因此遇到了一些比较值得一说的牌型：

比如遇到的第一个平和是在第 209 位小数，数列是7 5 6 6 5 9 3 3 4 4 6 1 2 8，牌型是66 123 345 456 789，还是一个一气贯通

断幺九在第 222 位小数，数列是8 4 7 5 6 4 8 2 3 3 7 8 6 7，牌型是66 777 888 234 345

四暗刻在第 5391 位小数，数列是8 8 2 8 1 6 1 3 3 2 3 1 6 6，牌型是22 111 333 666 888

二杯口在第 15912 位小数，数列是8 5 7 4 5 6 9 8 1 4 7 1 9 6，牌型是11 456 456 789 789，这也是第一个七对子牌型（但规则只计算二杯口），下一个七对子牌型在 16834 位，但同样也是二杯口，再下一个则是 21513 的一色双龙会，国标役种。真正的七对子要到 35441 位才能遇到，6 4 6 4 5 5 1 2 7 8 1 2 7 8，牌型11 22 44 55 66 77 88

一色双龙会在第 21513 位小数，数列是5 7 2 3 9 7 3 9 5 1 2 8 8 1，牌型是123 123 55 789 789

九莲宝灯在第 32452 位小数，数列是9 2 1 9 5 1 9 6 7 5 1 4 8 3，牌型是111 234 55 678 999，还是个最漂亮的九莲宝灯。

四暗刻绿一色在第 162552 位小数，数列是4 2 4 3 3 3 4 8 8 2 2 6 6 6，牌型是222 333 444 666 88，显然这还是个纯绿一色。

最后回顾下一切的开端：

自动化制作周刊哔哩哔哩排行榜

Sun, 07 Mar 2021 00:00:00 +0000

总结一下周刊哔哩哔哩排行榜制作流程自动化过程中遇到的一些问题。

之前的周刊制作过程中，组员各自领取不同部分的制作任务，每一部分的内容格式包含在不同的 yml 文件中。

通常先把 yml 中的 av 号取出，去下载对应的视频到本地，然后人工浏览选择实际制作时选取的片段，记录下片段的开始时间，修改 yml 中的对应字段。然后上传修改完成的 yml，转换成之后导入 Vegas 时需要的 xml 文件。

由于旧流程的局限性，没有考虑到视频尺寸的适配，因此在导入 Vegas 后，往往要手动对齐所有视频。另外由于不同部分的效果不一致（比如是否有过渡场景），也没有在 yml 中进行区分，往往还要再手动调整。工作量本质不大，但其实都是可以进行优化的场景。

早几年的时候一直听说 Adobe After Effects 脚本如何如何强大，表达式如何如何好用。怎奈 javascript 从未接触，一直没能下决心去了解。这次也算是终于下了决心，开始了 AE 自动化制作周刊之路。

Vegas -> AfterEffects

流程整理

首先是重新整理一遍 Vegas 的工作流，尽可能符合原来人工的操作顺序，也方便我理清代码逻辑。

Vegas 的导入视频过程，使用的是 xml 还是 yml 文件其实没有本质的区别，需要的内容无非是导入哪个视频的哪个时间点，时长多久，视频如何定位到准确的位置，以及导入对应的图片素材，添加视频过渡效果等等。

确定基本顺序后，我就开始对照 Adobe 的文档，一步步的编写代码。有一说一，Adobe 的文档确实非常详细，比 Vegas 的文档看起来是清晰多了（最初的确考虑过直接用 Vegas 脚本来做）。

最初先写死了各种变量来进行调试，基本是写一行测试一行的方式。逐步学会了 AE 中如何使用脚本添加合成，再往合成中添加视频/图片层，调整视频的入点和出点等等。熟悉了之后，由于一个个视频的导入其实是非常模块化的操作，在复制粘贴了十几次代码后，我终于意识到应该把它抽象成函数调用。

编写函数调用

流程已经很清晰了，也熟悉了代码，函数要实现的事情其实很简单：

添加一个新图层，指定视频文件和时长节点
给视频图层添加时间出入点和过渡效果
给视频图层添加音频过渡效果

于是我分别编写了 AddLayer, AddVideoProperty, AddAudioProperty 三个函数，包装了 Adobe 的 layers.add 和 property.setValueAtTime 两个方法。

在编写函数的过程中，因为是 Vegas->AfterEffects 复刻，Vegas 中的过渡曲线我在 AE 中没有找到一致的傻瓜式功能，只能自己去实现曲线的效果。这里就遇到了 Adobe 文档“点到为止”的问题：它没有提供详细的示例代码。

原本是计划使用 AE 表达式（区别于 AE 脚本）来实现的，但是文档中对于如何添加表达式并没有解释的很详细，Google 和 StackOverflow 也没能提供有价值的信息。反复翻阅文档之后，我决定采用其他的方式来实现：通过微分法添加透明度/音频增益关键帧来逼近曲线效果。

于是 AddVideoProperty, AddAudioProperty 的主要代码就变成了基于三角函数的 property.setValueAtTime，复习正/余弦曲线方程的过程还真是有些令人怀念 (￣_,￣ )

函数的函数

对单个视频的函数完成之后，意识到单个 yml 文件其实就是一个更大的函数。

这时需要解决的就是之前提到的对于过渡场景有无的判断。为了能够将工作流无缝转换到 AE，此时不可能再对 yml 做新的要求，好在数量不多，这部分区别直接手工指定写死在代码中即可。

同时为了减少重复的代码，将原本写在 AddVideoProperty 函数中的视频定位部分的代码放到了这个大函数 AddRankPart 中，通过 for 循环迭代 yml 列表（这时其实还是一个写死的列表，而不是读取 yml 文件）的数据，对视频进行长宽比的判断同比缩放，再定位至正确的坐标。

另外为了兼容周刊的排名规则，即长期视频的出现会造成视频数量的变化，以及每部分排名中最后一个视频过渡效果与其他不同，和视频间是否需要过渡画面等做了相应的判断，最后通过额外的函数参数兼容了不同样式的榜单部分。

但由于主榜前三实在比较特殊，就没有使用 AddRankPart 而是直接重写了一遍逻辑。

插曲

在编写完整个自动化代码后，遇到了久未见到的视频源失效的特殊样式，需要在失效的视频上添加遮挡。Vegas 时期这也是靠人工完成的，因为失效视频已经极少遇到，采用的方案是添加一个 array 记录失效的视频，在 AddRankPart 的 for 循环中添加视频是否在 array 中的判断来解决。这就需要当出现此类情况的时候修改代码中的变量。

但新增一个文件来记录也是同样要人工修改，罢了，就这样吧。

定型文

榜单各个部分间的过渡画面都是不随榜单变化，或者素材文件名保持固定，这部分内容就直接使用 AddLayer, AddVideoProperty, AddAudioProperty 写死了逻辑和时间点。

之后把写死的测试数据改写成读取实际的 yml 文件内容和素材文件，然后就是大量的 MagicNumber 时间点和不断地调试。为了测试兼容性还试验了 AfterEffects 的不同版本，结果发现不同版本的 AE 使用的 js 版本大相径庭，各种神秘问题频出。最后还是放弃了去追求更高的兼容性，优先保障了较新版本的 2019CC 和 2020CC 的使用。

AfterEffects 的问题

音频处理

AE 作为视频软件，对音频的处理就显得较弱了，这本来不是什么大问题。

但是上榜的视频各自的音频增益相差很大，最为明显的是 UP 主的投稿视频和 B 站番剧的动画，后者音频增益比前者低了一个等级。

Vegas 中可以直接通过“音频标准化”操作简单解决这个问题。AE 其实也可以通过 Adobe 家族的兼容性，将工程导出使用 Premiere 或者 Audition 进行音频标准化，但这样一来就失去了“自动化”的目的。

那么有什么其他办法可以解决么？在咨询群友和同事的意见之后，ffmpeg-normalize进入了我的视野。

ffmpeg-normalize

简单而言，ffmpeg-normalize 是对 ffmpeg 中音量处理的一层包装，将整个过程自动化便于进行批量化的操作。

试验之后发现果然方便，于是立刻开始编写代码。因为 CMD 过于简陋，选择了 powershell 来进行批处理。

然而在试运行一周后，发现大文件处理效率是个问题。对于动辄 600MB~1G 的番剧区视频，ffmpeg-normalize 处理整个文件所消耗的时间甚至超过了最后 AE 导出视频的时间，这就比较难接受了。而且它也不支持只对视频/音频的某一部分进行标准化操作，非常尴尬。

ffmpeg 视频截取&音频处理

既然 ffmpeg-normalize 是 ffmpeg 的包装，自然想到了直接用 ffmpeg 不也可以吗？还能少装一个 python，降低了其他组员的学习成本。

为了提升处理效率，与其处理整个视频，不如只处理选取的视频片段。于是在刚刚学习完 JavaScript 后，我又开始翻阅 powershell 的文档，研究怎样用 powershell 实现读取 yml 中的数据，传递给 ffmpeg 截取视频，并标准化截取视频的音频。

这种不同语言间的语法差异着实又烦恼了我一阵子，好在微软的文档也很详尽，绕了几次弯路后找到了正确的写法，实现了需求。

考虑到现在大家基本上都有不错的显卡，调用 ffmpeg 截取时使用 GPU 编/解码又能进一步提升效率，但使用 GPU 不能发挥 powershell 的并发能力，这受制于显卡的硬件，但仍比 CPU 编码快上不少。

然而在音频标准化处理上，GPU 就没有用武之地了，只能依赖 CPU 处理，与此同时可以依靠 powershell 的 ForEach-Object -Parallel 并发加快处理速度。只能说这两者算是有失有得吧。

对应修改

视频先行截取意味着之前 AE 脚本中读取的视频时间点全部无效了，于是修改了对应的变量在读取数据后直接重新赋值为零，纠正了时间问题。

PowerShell 工作流

既然 powershell 并发这么好用，我又动了新的歪脑筋，想起了之前 python 写的 B 站视频下载工具。

因为已经尝试重构过 bash 的代码，在熟悉了 powershell 的部分函数后，这部分重构也是轻车熟路。很快一个读取分析 yml 文件自动下载视频的 powershell 脚本就编写完成了。

不仅并发下载的代码逻辑比 python 简洁多了，甚至又填坑了之前想要指定下载分 P 的 TODO。另外 python 版的代码在下载时调用了 aria2c，powershell 的重构中也放弃了这部分依赖，如此一来整个工作流的外部依赖就只有 ffmpeg 了。

为了完全抛弃 python 脚本的依赖，周刊使用的生成传送门评论的脚本（没错，这个也是 python）当然也要用 powershell 重构，事情到了这一步已经无法停下脚步了（ry

最后，download.ps1, normailze.ps1, rankdoor.ps1 组成了周刊自动化中 powershell 工作流的三剑客。

未尽之事

如此一来，制作周刊还剩下的人工操作就只有选取视频片段一项了。但是这也已经有了尝试性的解决方案（Artificial Idiot 截取片段试运行），目前仍是个 python 脚本，也许成熟之后也会再重构为 powershell，到时就是四剑客了。

如果你对以上内容有兴趣，相关脚本在 Github 已开源。如果你不知道周刊哔哩哔哩排行榜，你也可以选择关注了解一下。

EOF

powershell 真香（

试做了一个明日方舟的小夜灯

Tue, 12 Jan 2021 00:00:00 +0000

之前也有在尝试用 3D 打印做奇怪的东西，建模一直在用的是 AutoDesk 家的线上工具Tinkercad，属于那种拖拖拽拽就能拼出差不多模型的工具，还挺好用。

这次尝试做小夜灯，原本是打算做成游戏关卡结算时的三星标志，后来想了想，为了更显而易见的突出方舟元素，用了游戏里医疗干员的标志。主要因为医疗干员的标志几何对称性很好，估摸着可以偷懒。

软件用了同事推荐的OpenSCAD，通过代码的方式来进行建模。我基本上是一边查文档一边写，很容易就上手找到需要的功能写出来了。

除了没有代码自动格式化这一点略有不习惯，代码逻辑支持实体的交并补操作，渲染后可以意见导出 stl 格式文档进行后续打印工作，实在是方便的很。

放两张成果图，使用的是创想三维的 Ender-3 打印机。冬天材料热涨冷缩比较严重结果留下了两道印子，有点可惜。

电池盒是圣诞节的时候那种细绳装饰灯的电池，考虑到亮度和分散光源，接了一个 COB 灯板。

工程文件放在github上了。

Python 使用 USB 热敏打印机

Tue, 07 Jul 2020 00:00:00 +0000

通过使用 python-escpos 库，就可以和常见的 USB 热敏打印机通信来进行打印，不再赘述具体方法。

但是 python-escpos 库并不是为 Windows 写的，实际在使用的时候就会出现许多的问题。

一个常见的错误是

usb.core.NoBackendError: No backend available

下载安装 CH341SER.EXE 并重启

escpos.exceptions.USBNotFoundError: USB device not found

ValueError: No backend available

根据Stackoverflow上的解答，应该是缺少 dll 文件，按解答中提供的链接地址下载安装就行了。

但安装后会出现新的错误：

NotImplementedError: Operation not supported or unimplemented on this platform

所幸在 python-escpos 的 Github issue316中有人提供了解决方式。直接修改源代码，删去对应的异常捕捉，就能够正常使用了。

此处留档以备不时之需。

Windows 10 使用 OpenSSH + Rsync/SCP 同步文件

Sun, 03 May 2020 00:00:00 +0000

疫情期间在家工作一直使用公司的 VPN，于是在公司电脑开了共享用来传输文件。但不知道为什么，公司->家方向传文件很顺畅，反方向传文件时就经常会出现进度条走到末尾就停住，要多等一段时间才能传输结束的问题。

虽然可以考虑用 OneDrive 这类网盘来进行同步，但这样的同步不够实时，而且毕竟要从三方服务器绕一圈，上传速度波动也很大。

想到既然 Windows 10 支持了 OpenSSH，家里和公司电脑又都装了 WSL，也许可以用 rsync/scp 来解决这个问题。

安装 OpenSSH Server

Windows 10(1809) 虽然自带了 OpenSSH 的 Server 和 Client，但默认并没有安装。

参照Microsoft 的文档给两台电脑都安装 OpenSSH：

Get-WindowsCapability -Online | ? Name -like 'OpenSSH*'

# This should return the following output:
Name : OpenSSH.Client~~~~0.0.1.0
State : NotPresent
Name : OpenSSH.Server~~~~0.0.1.0
State : NotPresent

# Install the OpenSSH Client
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

# Install the OpenSSH Server
Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0

# Both of these should return the following output:
Path :
Online : True
RestartNeeded : False

Start-Service sshd
# OPTIONAL but recommended:
Set-Service -Name sshd -StartupType 'Automatic'
# Confirm the Firewall rule is configured. It should be created automatically by setup.
Get-NetFirewallRule -Name *ssh*
# There should be a firewall rule named "OpenSSH-Server-In-TCP", which should be enabled
# If the firewall does not exist, create one
New-NetFirewallRule -Name sshd -DisplayName 'OpenSSH Server (sshd)' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22

这时候就可以从其中一台电脑向另一台发起 SSH 连接了。

生成 SSH 密钥并部署

考虑到之后计划使用 rsync 传输，与 Linux 类似，我们可以使用密钥登陆的方式来避免每次都要输入密码。

先设定作为 Client 的电脑：

# 提示输入生成密钥的文件名，这里假设是 client_rsa
ssh-keygen

# 启动ssh-agent服务
Get-Service -Name ssh-agent | Set-Service -StartupType 'Automatic'
Start-Service ssh-agent

# 导入密钥
ssh-add client_rsa

先通过密码登录的方式 SSH 连接到 Server 的电脑上：（注意替换成自己的 server_user 和 client_user）

ssh server_user@Server_ip

mkdir C:\Users\server_user\.ssh\

scp C:\Users\client_user\.ssh\client_rsa.pub server_user@Server_ip:C:\Users\server_user\.ssh\authorized_keys

退出 SSH 会话，然后重新连接，这时应该已经不需要再输入密码了。

设置到这里的时候踩到一个坑：如果 SSH 登录的 Server 用户是管理员身份的话，authorized_keys需要存到C:\ProgramData\ssh\administrators_authorized_keys这个位置。

不然的话此时 SSH 登录仍然会要求密码。

ssh server_user@Server_ip

scp C:\Users\client_user\.ssh\client_rsa.pub server_user@Server_ip:C:\ProgramData\ssh\administrators_authorized_keys

# 修正ACL权限
$acl = Get-Acl C:\ProgramData\ssh\administrators_authorized_keys
$acl.SetAccessRuleProtection($true, $false)
$administratorsRule = New-Object system.security.accesscontrol.filesystemaccessrule("Administrators","FullControl","Allow")
$systemRule = New-Object system.security.accesscontrol.filesystemaccessrule("SYSTEM","FullControl","Allow")
$acl.SetAccessRule($administratorsRule)
$acl.SetAccessRule($systemRule)
$acl | Set-Acl

之后对调 Client 和 Server 的身份再做一次同样的事情就可以了。

进入 WSL 部署 rsync

只用 scp 存在着一定的局限性，若要使用 rsync 则需要依靠 WSL 了。

依旧从 Client 开始设置：

cd ~/.ssh

cp /mnt/c/Users/client_user/.ssh/client_rsa ./client_rsa

cp /mnt/c/Users/client_user/.ssh/client_rsa.pub ./client_rsa.pub

chmod 600 client_rsa

转到 Server 上：

cd ~/.ssh

cp /mnt/c/Users/server_user/.ssh/authorized_keys ./authorized_keys

假设 Client 的 D 盘有个 testfile 的文件，测试 rsync：

# --rsync-path="wsl rsync" 用来指示Server通过wsl启动rsync环境
rsync -rtuv -e "ssh -i ~/.ssh/client_rsa" /mnt/d/testfile server_user@Server_ip:/mnt/d/ --rsync-path="wsl rsync"

如果一切正常，应该不会提示输入密码，然后你能在 Server 的 D 盘看到这个文件。

同样，对调 Client 和 Server 的身份再设定一次就可以双向操作了。

EOF

Windows 使用 WSL 配置 crontab 定时任务

Sat, 25 Jan 2020 00:00:00 +0000

有些 python 脚本任务对于树莓派来说还是负担太重了。毕竟性能上限摆在那里，也不能靠一个小小的 pi 承担太多。

借此机会正好尝试一下 WSL(Windows Subsystem for Linux).

安装 WSL

安装 WSL 并没有想象中的复杂。进入控制面板->程序和功能->启用或关闭 Windows 功能，勾选适用于Linux的Windows子系统，等待安装完毕，然后重启系统。

重启完毕，开始菜单选择 MicrosoftStore，搜索 linux 就能够找到可供使用的 linux 发行版，我这里选择了 Ubuntu18.04LTS。

应用安装完毕后，启动应用会要求设定基础的用户名和密码，接着，一个可供使用的 WSL 就准备就绪了。

确保 crontab 服务

由于 WSL 并不会默认启动，而且当运行中的 WSL 的最后一个 bash 关闭后，就相当于关闭了整个子系统，那我们的 crontab 也就直接去世了。

为了保持 crontab 常驻，需要一些措施。这里参考了Schedule Tasks Using Crontab on Windows 10 with WSL的方法，建立一个 crontab 服务的 Windows 启动项，每次系统启动后在后台常驻。

首先进入 WSL，修改 sudoer，避免每次启动 crontab 服务时需要输入密码确认：

sudo visudo

在文件末尾加入

%sudo ALL=NOPASSWD: /etc/init.d/cron start

然后保存文件。回到 Windows，Win+R 打开运行，输入shell:startup打开启动文件夹，右键新建快捷方式，目标输入：

C:\Windows\System32\wsl.exe sudo /etc/init.d/cron start

这样我们就能够保证 crontab 在每次 Windows 启动后常驻后台了。一切正常的话重启 Windows，在任务管理器能看到一个名称为 cron 的进程。

使用 crontab

剩下的操作和在 linux 里使用 crontab 没有区别，唯一需要注意的是文件的路径。

在 WSL 中，Windows 的 C 盘被挂载在/mnt/c目录下，D\E\F 以此类推，需要注意对应修改。

EOF

来一场圆周率的飞花令

Tue, 26 Nov 2019 00:00:00 +0000

逛微博看到了一些有意思的东西：山东卫视《国学小名士》第三季的节目，进行了一场 π(圆周率) 的飞花令。

节目里选手们接到了小数点后 204 位，那，能不能更长一点？

数据储备

首先需要有足够多的古诗词储备，不然程序生成的时候耗光弹药就显得非常尴尬了。

非常感谢chinese-poetry这样的开源项目，积累了大量的已经结构化的古诗词数据。

这里只用宋词部分的数据。

算法逻辑

逻辑很简单粗暴：找出所有包含中文数字的词句进行汇总，然后按小数点后位数迭代 π 值随机取对应的诗词就行。

整理诗词数据：

import json
import re
import os

filelist = [
 file for file in os.listdir('./json') if re.search(r'poet.song', file)
]

files = [
 json.load(open('./json/' + file, 'r', encoding='utf-8-sig'))
 for file in filelist
]

result = {
 '一': [],
 '二': [],
 '三': [],
 '四': [],
 '五': [],
 '六': [],
 '七': [],
 '八': [],
 '九': [],
 '零': []
}

for file in files:
 for x in file:
 for y in x['paragraphs']:
 for z in ['一', '二', '三', '四', '五', '六', '七', '八', '九', '零']:
 　 if re.search(z, y):
 result[z] = result.get(z) + [
 '{}\n\t\t\t\t{}/{}'.format(y, x['author'], x['title'])
 ]

with open('step.json', 'w', encoding='utf-8-sig') as f:
 f.write(json.dumps(result, ensure_ascii=False))

π 值计算

无脑套用了一下别人的代码：http://z-rui.github.io/post/2015/06/pi-digits/

def pidigits():
 q, r, t, u, i = 1, 180, 60, 168, 2
 while True:
 y = r // t
 yield y
 q, r, t, u, i = 10 * q * i * (2 * i - 1), 10 * u * (
 q * (5 * i - 2) + r - y * t), t * u, u + 54 * (i + 1), i + 1

不停迭代 pidigits() 就能得到后一位小数数值。

开始飞花令

测试一下迭代圆周率 1000 位

import json
import sys
from random import randint

poets = json.load(open('step.json', 'r', encoding='utf-8-sig'))

number = {
 1: '一',
 2: '二',
 3: '三',
 4: '四',
 5: '五',
 6: '六',
 7: '七',
 8: '八',
 9: '九',
 0: '零'
}

n = 0


def pidigits():
 q, r, t, u, i = 1, 180, 60, 168, 2
 while True:
 y = r // t
 yield y
 q, r, t, u, i = 10 * q * i * (2 * i - 1), 10 * u * (
 q * (5 * i - 2) + r - y * t), t * u, u + 54 * (i + 1), i + 1


while True:
 f = open('result.md', 'w', encoding='utf-8-sig')
 for num in pidigits():
 used = []
 new = poets[number[num]].pop(randint(0, len(poets[number[num]])))
 while new in used:
 new = poets[number[num]].pop(randint(0, len(poets[number[num]])))
 print(num, number[num], new)
 f.write('{}\t{}\t{}\n'.format(
 num, number[num],
 new.replace(number[num], '`{}`'.format(number[num]))))
 used = used.append(new)
 n += 1
 if n > 1000:
 f.close()
 sys.exit()

EOF

哔哩哔哩下载工具三

Sat, 16 Nov 2019 00:00:00 +0000

有生之年我最后居然是用 Shell 来填了分 P 的 TODO……

cURL - 命令行下的文件传输工具

cURL 这个工具太过强大，我也不知道该怎么去解释它比较好。几乎所有的网络访问，上传下载，都能够使用 cURL 来完成。

也难怪诸如 Chrome 和 Firefox 等浏览器，会支持复制网络访问为 cURL。而其实我也一直依靠这个功能，通过https://curl.trillworks.com/来快速写我的 python 爬虫。

大部分的工作都可以直接靠右键复制为 cURL 来完成，所以只需要简单的查看下 cURL 的说明，便于进行一些小的修改就行。

然后开始对照之前写的 python 脚本的逻辑，一步步转成 Shell 脚本。

jq - 命令行下的 JSON 处理工具

B 站 API 接口的各种返回数据以 JSON 为主，直接靠 awk/sed 手撸解析是一件很痛苦的事。所以我们需要用上 jq 这个工具减轻负担。

jq 解析 JSON 数据非常的便捷，比如获取分 P 数据时：

{
 "code": 0,
 "message": "0",
 "ttl": 1,
 "data": [
 {
 "cid": 73802454,
 "page": 1,
 "from": "vupload",
 "part": "3",
 "duration": 66,
 "vid": "",
 "weblink": "",
 "dimension": {
 "width": 1920,
 "height": 1080,
 "rotate": 0
 }
 }
 ]
}

↑ jq 的另一个作用就是格式化 json 数据，比如上面的代码就是通过cat result.json | jq .自动格式化出来的。

要取得分 P 的 cid，我们可以： curl -sL 'https://api.bilibili.com/x/player/pagelist?aid=42038790&jsonp=jsonp' | jq -r '.data[0].cid'

如果有多个分 P，我们可以这样取得所有的 cid： curl -sL 'https://api.bilibili.com/x/player/pagelist?aid=42038790&jsonp=jsonp' | jq -r '.data[].cid'

真的是非常方便。

sed - 支持正则表达式的流编辑器

考虑到 windows 上的兼容性，如果用视频标题做文件名，势必要排除/?!.*|:等特殊字符。这时我们就可以用 sed 来完成： curl -sL -H https://api.bilibili.com/x/web-interface/view?aid=42038790 | jq -r '.data.title' | sed 's/[/?!.*|:]//g'

再后面我们会更多的用到 sed。(Flag)

编写 Shell 脚本

$1 代表了命令行传给脚本的第一个参数，使用场景类似 bash download.sh av42038790 通过 sed，我们可以兼容 bash download.sh https://www.bilibili.com/video/av42038790?from=search&seid=3037567923943401758 的链接模式。

aid=`echo $1 | sed -e 's/.*av//g' -e 's/[a-zA-Z?/].*//g'`

Shell 脚本中声明变量时等号前后都不能有空格，使用变量时在变量前加上$

pagelist='https://api.bilibili.com/x/player/pagelist?aid='$aid'&jsonp=jsonp'
cids=`curl -sL $pagelist | jq -r '.data[].cid'`

这里的 cids 只是一个包含空格分隔的字符串123 234 345，为了让 Shell 正确计数，把它转为数组

cids_arr=($cids)

这样一来通过${ #cids_arr[@] }就能够正确得出 cids 中的元素个数

接下来通过 for 循环遍历 cids 中的元素，为了能同时计算元素的个数，需要另行计数：

part=0
for cid in $cids
do
 episode=$(( ++part ))
 #some code
done

Shell 中的 if else 判断以 if 开始，fi 结束：

 if [ "${#cids_arr[@]}" == "1" ]
 then
 filename=av$aid.$title.mp4 # 视频只有1P时，不标注分P
 else
 filename=av$aid.$title【P$episode】.mp4 # 多P视频标注分P
 fi

判断视频是 DASH 还是 FLV：

json_url='https://api.bilibili.com/x/player/playurl?avid='$aid'&cid='$cid'&qn=116&fnver=0&fnval=16&otype=json&type='
json=`curl -sL $json_url`
dash=`echo $json | jq '.data|has("dash")'`
durl=`echo $json | jq '.data|has("durl")'`

处理 DASH 视频：

if [ "$dash" == "true" ]
then
 vp=`echo $json | jq -r '.data.dash.video[0].baseUrl'` # 视频
 ap=`echo $json | jq -r '.data.dash.audio[0].baseUrl'` # 音频

aria2c --args $vp --out ./v_$cid.m4s
aria2c --args $vp --out ./a_$cid.m4s
ffmpeg -i ./v_$cid.m4s -i ./a_$cid.m4s -c:v copy -c:a copy ./$filename
rm *.m4s

处理 FLV 视频：

elif [ "$durl" == "true" ]
then
 flvs=`echo $json | jq -r '.data.durl[].url'`
 for flv in $flvs
 do
 echo "file './"$flvname"'" >./merge_$cid.txt
 flvname=`echo $flv | sed -e 's/\?.*//g' -e 's/.*\///g'`
 aria2c --args $flv --out ./$flvname
 ffmpeg -safe 0 -f concat -i ./merge_$cid.txt -c copy ./$filename
 rm *.flv
 rm ./merge_$cid.txt

使用 shift

shift 命令的作用是左移参数，举例来说，如果我们传给脚本 3 个参数 a,b,c，脚本接收到的参数为：

echo $1 $2 $3
a b c

当我们执行 shift 后

shift
echo $1 $2 $3
b c

这样就可以在循环中一直只处理$1，直到所有参数左移完毕。

先判断没有参数时退出脚本：

if [ $# -eq 0 ]
then
 echo -e "->Need AVID to download!\n"
 exit 1
fi

加上 shift 和循环：

until [ $# -eq 0 ]
do
 aid=`echo $1 | sed -e 's/.*av//g' -e 's/[a-zA-Z?/].*//g'`
 #some code
 shift
done

记得加上 Cookies

要获得高清源必须在访问 API 时加上 Cookies，cURL 要做到这点很简单。

测试得知判断的关键是 Cookies 的如下键值： DedeUserID=; DedeUserID__ckMd5=; SESSDATA=; bili_jct=

F12 打开浏览器，找到对应的键值，保存成 Cookies 的文本文件，然后修改代码：

cookies=`cat ./cookies`
curl -sL -H "Cookie: "$cookies
aria2c --header="Cookie: "$cookies

完整代码

#!/bin/sh
IFS=$'\n'
if [ $# -eq 0 ]
then
 echo -e "->Need AVID to download!\n"
 exit 1
fi
until [ $# -eq 0 ]
do
 aid=`echo $1 | sed -e 's/.*av//g' -e 's/[a-zA-Z?/].*//g'`
 cookies=`cat ./cookies`

 pagelist='https://api.bilibili.com/x/player/pagelist?aid='$aid'&jsonp=jsonp'
 echo -e "->Getting video list: \n"$pagelist
 cids=`curl -sL -H "Cookie: "$cookies $pagelist | jq -r '.data[].cid'`
 title=`curl -sL -H "Cookie: "$cookies 'https://api.bilibili.com/x/web-interface/view?aid='$aid | jq -r '.data.title' | sed 's/[/?!.*|:]//g'`
 cids_arr=($cids)
 echo -e "->Found video pages: "${#cids_arr[@]}

 part=0
 for cid in $cids
 do
 episode=$(( ++part ))
 echo -e "->Download video page: "$episode
 if [ "${#cids_arr[@]}" == "1" ]
 then
 filename=av$aid.$title.mp4
 else
 filename=av$aid.$title【P$episode】.mp4
 fi
 json_url='https://api.bilibili.com/x/player/playurl?avid='$aid'&cid='$cid'&qn=116&fnver=0&fnval=16&otype=json&type='
 echo -e "->Getting video source: \n"$json_url
 json=`curl -sL -H "Cookie: "$cookies $json_url`
 dash=`echo $json | jq '.data|has("dash")'`
 durl=`echo $json | jq '.data|has("durl")'`

 if [ "$dash" == "true" ]
 then
 vp=`echo $json | jq -r '.data.dash.video[0].baseUrl'`
 ap=`echo $json | jq -r '.data.dash.audio[0].baseUrl'`

 echo -e "->Downloading Video Dash"
 aria2c -x10 -k1M --file-allocation=none --auto-file-renaming=false --allow-overwrite=true $vp\
 --show-console-readout false --quiet \
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av"$aid\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache"\
 --header="Cache-Control: no-cache"\
 --header="Cookie: "$cookies \
 --out ./v_$cid.m4s

 echo -e "->Downloading Audio Dash"
 aria2c -x10 -k1M --file-allocation=none --auto-file-renaming=false --allow-overwrite=true $ap\
 --show-console-readout false --quiet \
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av"$aid\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache"\
 --header="Cache-Control: no-cache"\
 --header="Cookie: "$cookies \
 --out ./a_$cid.m4s

 echo -e "->Merge into file: "$filename
 ffmpeg -i ./v_$cid.m4s -i ./a_$cid.m4s -c:v copy -c:a copy\
 -y -hide_banner -loglevel panic \
 ./$filename
 echo -e "->Removing temp files\n"
 rm *.m4s
 elif [ "$durl" == "true" ]
 then
 flvs=`echo $json | jq -r '.data.durl[].url'`
 for flv in $flvs
 do
 flvname=`echo $flv | sed -e 's/\?.*//g' -e 's/.*\///g'`
 echo "file './"$flvname"'" >./merge_$cid.txt
 echo "->Downloading Video Part: "$flvname
 aria2c -x10 -k1M --file-allocation=none --auto-file-renaming=false --allow-overwrite=true $flv\
 --show-console-readout false --quiet \
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av"$aid\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache" --header="Cache-Control: no-cache"\
 --header="Cookie: "$cookies \
 --out ./$flvname
 done
 echo "->Merge into file: "$filename
 ffmpeg -safe 0 -f concat -i ./merge_$cid.txt -c copy\
 -y -hide_banner -loglevel panic \
 ./$filename
 echo -e "->Removing temp files\n"
 rm *.flv
 rm ./merge_$cid.txt
 else
 echo -e "->Error: Video not found!\n"
 fi
 done
 shift
done

EOF

清晰度选择我觉得就真的没必要了吧.jpg

但是 jq 毕竟是个第三方工具，难道真的不能用 awk/sed 来解析 json 吗？

可以，但没必要。

但今天就尝试一次，用 awk 和 sed 组合，替换掉 jq 的工作：

# 获取cids
cids=`curl -sL -H "Cookie: "$cookies $pagelist | sed 's/[{,}]/\n/g' | awk -F: '/"cid"/ {print $2}'`

# 获取视频标题
title=`curl -sL -H "Cookie: "$cookies 'https://api.bilibili.com/x/web-interface/view?aid='$aid | sed -e 's/[{}]//g' -e 's/,"/\n"/g' | awk -F: '/"title"/ {print $2}' | sed -e 's/"//g' -e 's/[/?!.*|:]/-/g'`

# 是否是DASH
dash=`echo $json | sed -e 's/[{}]//g' -e 's/,"/\n"/g' | awk '/"dash"/'`

# 是否是FLV
durl=`echo $json | sed -e 's/[{}]//g' -e 's/,"/\n"/g' | awk '/"durl"/'`

if [ "$dash" != "" ]
then
 # 视频 DASH
 vp=`echo $json | sed -e 's/[{}]//g' -e 's/,"/\n"/g' -e 's/\]//g' | awk '/"video"/,/"audio"/' | awk '/"baseUrl"/' | sed -e 's/"baseUrl"://g' -e 's/"//g' -e 's/\u0026/\&/g' -e 's/\\\\//g' | awk 'NR==1'`

 # 音频 DASH
 ap=`echo $json | sed -e 's/[{}]//g' -e 's/,"/\n"/g' -e 's/\]//g' | awk '/"audio"/,/""/' | awk '/"baseUrl"/' | sed -e 's/"baseUrl"://g' -e 's/"//g' -e 's/\u0026/\&/g' -e 's/\\\\//g' | awk 'NR==1'`

elif [ "$durl" != "" ]
then
 # FLV 视频
 flvs=`echo $json | sed -e 's/[{}]//g' -e 's/,"/\n"/g' -e 's/\]//g' | awk '/"url"/' | sed -e 's/"url"://g' -e 's/"//g' -e 's/\u0026/\&/g' -e 's/\\\\//g'`
else
 echo -e "->Error: Video not found!\n"
fi

配置 Cmder 整合 Cygwin 与 Github

Sat, 19 Oct 2019 00:00:00 +0000

记录下折腾 Cmder 的过程。

虽然群友安利了许久的 WSL 和 Powershell，但对于前两者的 GUI 我实在看不下去。也许他们真的很棒，但好用的工具似乎注定了不能拥有好看的 UI。

而我，还是倾向于 UI 舒服的。毕竟只要它真的不是功能上缺胳膊少腿儿，剩下的事情，大部分都可以克服。

再说了，不多折腾折腾，不多踩几个坑，多 Google 和 Stackoverflow 一下，你怎么会知道原来世界上还能有这种问题呢.jpg

初始化

我们可以从Cmder 的主页下载它的最新版（当前是 v1.3.12）。为了避免之后和 Github 以及 Cygwin 附带的命令出现不同版本并存的问题，选择Download Mini。

下载完毕后解压，先把 Cmder 添加到右键菜单，方便之后随时调用。在解压目录打开一个管理员权限的 Powershell：

Cmder.exe /REGISTER ALL

接下来先放着 Cmder 不管，继续装 Git for windows。

从Git for windows 的主页下载最新版，安装基本都是默认选项，需要注意的是：

Adjusting your PATH enviroment选择Use Git from the Windows Command Prompt
Configuring the line ending conversions选择Checkout Windows-style, commit Unix-style line endings
Configuing the terminal emulator to use with Git Bash选择Use MinTTY

额外选项可以默认也可以不选，安装完成后在任意目录右键，应该能看见Git Bash Here和Git GUI Here的选项。

接着继续，安装 Cygwin。

在Cygwin 官网下载对应版本（64-bit/32-bit），双击执行，默认选项即可。

在Choose A Download Site这步，我们可以添加清华大学的镜像源https://mirrors.tuna.tsinghua.edu.cn/cygwin/来提升软件包的下载速度，然后点击下一步。

在 Search 中搜索 wget，下拉菜单将 Skip 替换成其中一个版本安装，这是之后安装 apt-cyg 需要的依赖。另外检查 gwak、tar、bzip2 这几个包是否安装（不是 Skip 就对了）。

有需要的话可以自己选择还要安装哪些命令，不过这些都可以之后再改，先接着继续下一步默认安装就可以了。

折腾

现在我们有了 Cmder+Github+Cygwin，接下来把他们整一起。

git 比较方便，打开控制面板，选择系统和安全->系统->高级系统设置->环境变量，在用户变量里选择Path->编辑，如果是默认安装的话，应该会有一条C:\Program Files\Git\usr\bin的记录，如果没有可以手动添加。

然后打开 Cmder，输入 git 并回车，检查是否能够调用 git。

Cygwin 按照同样的方式加入系统环境变量，默认路径是C:\cygwin64\bin，如果修改了安装路径需要对应修改。

接着安装 apt-cyg，有了它就可以像 Ubuntu 管理软件包一样随意 install 需要的命令了。

apt-cyg 的项目主页是 https://github.com/transcode-open/apt-cyg ，在 Release 页面下载最新版，解压将apt-cyg文件移动到C:\cygwin64\bin，打开 cygwin 终端：

apt-cyg install nano

测试 apt-cyg 是否正常工作。

为了解决中文编码问题，在 Cygwin 终端窗口右键选择Options，选择Text，更改locale为zh_CN，Character set为UTF-8。

然后 nano 或者 vi 编辑~/.bashrc文件，在文件最后添加：

export LC_ALL=zh_CN.UTF-8
export LC_CTYPE=zh_CN.UTF-8
export LANG=zh_CN.UTF-8

为了 Cygwin 和 Cmder 整合后，能够识别当前工作目录，通过 apt-cyg 安装 chere 命令：

apt-cyg install chere

然后还是编辑~/.bashrc，追加内容：[参考 1]

if [ -n "${ConEmuWorkDir}" ]; then
 cd "$ConEmuWorkDir"
fi

Cygwin 中 C 盘的路径映射为/cygdrive/c，如果觉得太长的话，可以在 cygwin 终端里修改/etc/fstab或者直接修改C:\cygwin64\etc\fstab:

# /etc/fstab
#
# This file is read once by the first process in a Cygwin process tree.
# To pick up changes, restart all Cygwin processes. For a description
# see https://cygwin.com/cygwin-ug-net/using.html#mount-table
# This is default anyway:
# none /cygdrive cygdrive binary,posix=0,user 0 0
none / cygdrive binary 0 0

之后 C 盘映射到/c，D 盘映射到/d，以此类推。

以上设置完可以算是告一段落了，接着把 Cygwin 整进 Cmder 里。

打开 Cmder，右键选择Settings，选择Startup->Tasks。

点击’+‘号添加新的 Task，Task Name填一个能区分出是 Cygwin 的，比如Cygwin::bash，Task parameters填写/icon C:\cygwin64\Cygwin-Terminal.ico，在Commands中填写set CHERE_INVOKING=1 & C:\cygwin64\Cygwin.bat -c "/bin/xhere /bin/bash.exe --login -i '%V'"参考 2

然后勾选上Default task for new console和Taskbar jump lists。回到Startup，选择Specified named task->Cygwin::bash。

这样一来 Cmder 的默认终端就是 Cygwin 了，git 命令和 windows 本身的支持也没有问题。

进一步调整

`General`->`Fonts`

先解决编码问题，选择General->Fonts->Unicode ranges->CJK: 2E80-9FC3;AC00-D7A3;F900-FAFF;FE30-FE4F;FF01-FF60;FFE0-FFE6;->Apply。

Font charset还是保持 ANSI，否则 Cmder 会报错Failed to create font然后 fail back 回缺省字体。

然后选择Startup->Environment，添加如下内容：

set PATH=%ConEmuBaseDir%\Scripts;%PATH%
set LANG=zh_CN.UTF8

接着是字体，中文字体真的太少了，好看的就更少了。（有一说一，我觉得，确实，是这样的）

选了 Powerline Fonts：

git clone https://github.com/powerline/fonts.git

我单独装了Noto Mono for Powerline，也可以选择执行install.ps1直接安装全部的字体。

在Main console font选了Noto Mono for Powerline后，中文还是会 fail back 成宋体，这里勾上Alternative font，选择微软雅黑 Light，个人感觉不违和，能看。

其他勾选上Monospace和Compress long strings to fit space。

`General`->`Size & Pos`

将Width改为 80%，Height改为 70%，这样 Cmder 启动会自动根据显示器大小调整窗口大小。

`General`->`Background`

设置Background Image和Darkening可以给终端添加图片背景并调整图片透明度，我就敬谢不敏了。

`General`->`Confirm`

去除Confirm creating new console/tab和Confirm tab duplicating的勾选，这两个太烦人了。

`Features`->`Transparency`

Alpha transparency可以调整终端窗口本身的透明度，我这里直接拖到了最右边不透明。屡次截图终端映出了背后的内容总是让我心有余悸。

`Keys & Macro`->`Paste`

确保两个Paste mode都是Multi lines，避免行为不一致。

其他

Cmder 有自己的user_alias(“Cmder/config/user_alias.cmd”) 可以很方便的设定一些常用命令，可以在 cmd 或者 powershell 终端里使用，但是不能和 Cygwin 通用。Cygwin 需要 Alias 的话还是得老老实实编辑~/.bashrc。
Cmder 可以作为 Sublime Text 的终端来使用，Sublime 安装 Terminal 插件，设置终端路径为 Cmder 安装路径即可。默认呼出终端的快捷键是 Ctrl+Shift+T。
Cygwin 有个已知问题，Ctrl+方向键没有绑定操作，需要手动添加，方法是编辑~/.inputrc添加两行内容"\e[1;5C": forward-word和"\e[1;5D": backward-word。[参考 3]
如果之前已经生成了 SSH KEY 的话，需要手动复制到C:\cygwin64\home\<user name>\.ssh或者直接指定 ssh key 才能让 git 识别到。

EOF

jojo，python 的能力是有极限的

Fri, 18 Oct 2019 00:00:00 +0000

–> jojo，python 的能力是有极限的。

–> 我从短暂的人生当中学到一件事……

–> 越是玩弄代码，就越会发现 python 的不足……

–> 除非超越 python。

你到底想说什么？

–> 吔我 bash 啦！

起因

原因其实很简单，工作上需要使用后台导入些数据。

吭哧吭哧把原始数据整理完，搞成 csv 了，点个“导入”，给我来了个报错：

单次导入只支持 1000 条

崽啊，9102 年末了，我 csv 里面近百万条数据，你跟我说一次 1000？我不下班啦？

然而优秀的底层员工是不会抱怨这些事情的，行吧，我自己切表总行了吧。

尝试 python 切割

先用 python 瞎糊了一个：

datas = {}
for n, line in enumerate(open('test.csv', 'r', encoding='utf-8-sig')):
 if datas.get(n//1000):
 datas[n//1000] = datas[n//1000] + [line]
 else:
 datas[n//1000] = [line]

for k,v in datas.items():
 with open('test-{}.csv'.format(k), 'w', encoding='utf-8-sig') as f:
 f.write(''.join(v))

凑合着用了，顺便再写了个脚本把切好的文件自动导入到后台，把工作做完了。

但是回过头了，就开始嫌弃 python 不够快了。

虽然很明显原因在于我（毕竟瞎糊凑合用），想看能不能更快一点。

于是想起了 bash，想起了 split 和 xargs。

换成 bash

要切割文件的话 split 的确很方便：

split test.csv -l 1000 -d -a 3 test__

-d -a 3指定了按 3 位数递增添加后缀，这样就能产生 test001 ~ test999 命名的切割好的文件。

但新的问题也来了，切割完需要全部加上文件扩展名：

mv test_001 test-001.csv

但手工操作量还是太大，这时候我们就需要 xargs 了：

ls | grep test__ | xargs -n1 -I file mv file file.csv

ls | grep test__筛选了所有缺少扩展名的文件，管道命令传给 xargs 后，-n1代表一次接受一个参数，-I file告诉 xargs 后续命令中的file全部用参数值替换。

比如只有一个文件的时候，ls | grep test__只有一个结果test__001，xargs 接收到参数，将file替换成test__001，实际执行内容就是：

mv test001 test001.csv

将他们组合一下：

split -l 1000 test.csv -d -a 3 test**&& ls | grep test** | xargs -n1 -I file mv file file.csv

回车执行，1 秒都不需要，爽死了。

人类是懒惰的动物

但这样还是需要自己手打需要切割的文件名，不够爽。尝试把代码再变长一点：

ls | grep .csv$ | sed ’s/.csv//g’ | xargs -n1 -I file split -l 1000 file.csv -d -a 3 file**&& ls | grep** | xargs -n1 -I file mv file file.csv

以管道命令分割解释一下：

ls 列出当前目录下所有文件和子目录
grep .csv$ 筛选扩展名是 csv 的所有文件
sed 's/.csv//g' 去除扩展名，只留文件名
xargs -n1 -I file split -l 1000 file.csv -d -a 3 file__ 切割所有的文件
ls 列出当前目录下所有文件和子目录
grep __ 筛选文件名包含__的文件（上一步切割好的文件）
xargs -n1 -I file mv file file.csv 加上扩展名

爽又死了。

EOF

尝试在 windows 上（Cmder+Github）做类似的操作，发现远没有在虚拟机（Ubuntu）里执行快，垃圾微软.jpg

RSS 咕咕机

Wed, 02 Oct 2019 00:00:00 +0000

之前从同事那里二手买了个咕咕机，当玩具玩。享受了几天使用 APP 打印各种沙雕照片和表情包带来的乐趣后，它毫无意外的开始吃灰，就和桌子旁边的树莓派一样染上历史的颜色。

还是拿出来用用吧……

咕咕机 APP 里的一部分订阅号的确有点意思，比如订阅每天天气，早上 8 点自动打印一条天气内容之类的。那么拿来订阅微博更新好像也没什么不对的。

反正一天有 12 小时在公司，闲着也是闲着，不定时的来一段小纸条也不错。

开发者申请

为了做到这些，首先要去咕咕机的开发者页面申请 APPKEY。填写必要的信息然后提交申请就行了。等了一周左右申请就通过了。

拿到 APPKEY 之后，可以查阅官方给的文档，可用的 API 其实不多，更多还是要靠自己去生成内容。

GitHub上也有其他开发者写的 SDK，可以不用自己重复按照官方文档造轮子。

RSS

打个比方，订阅小狐狸的 B 站动态。

熟练的打开小狐狸的空间，F12，刷新，过滤 XHR，找到 API 接口https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history。B 站的动态有多种类型，需要根据类型判断爬取的内容。

['data']['cards']['desc']['type']的值表明了动态是何种类型，比如 1 是指转发，2 是带图动态，4 是纯文字动态，8 是投稿视频推送。

在 ['data']['cards']['card'] 中是一串 JSON 数据，动态的文本内容根据上面不同的类型存在不同的键值里，比如['dynamic']、['item']['content']、['item']['description']这几个位置。

图片存储

只有文本内容的纸条太单调了，信息量也不够，还是需要能够同时打印图片内容。但图片打印会增加打印时间和下载时间，折衷选择只保存附带图片的第一张。

为了保持目录整洁，图片数据全部用 sqlite3 存储。

内容更新

为了避免重复打印浪费纸张，每次爬取数据时需要判断是否有新的内容。

建数据表，只存储必要的时间、日期、文字内容和图片数据，加上动态的 ID 作为主键来进行去重。

CREATE TABLE
IF
 NOT EXISTS 白上吹雪Official (
 day VARCHAR,
 _id VARCHAR PRIMARY KEY UNIQUE,
 msg VARCHAR,
 pic BLOB,
 title VARCHAR);

然后人工插入一条 id 为 0 的数据，用来记录是否获取到新内容，每次先单独查询这一行，有新数据再取出内容进行打印。

POST 请求打印

利用之前提到的 SDK，将文字和图片的复合内容整合后一起 POST 给服务器。

小花样

为了区分普通的带图动态和视频投稿的推送，仿照动态的样式给视频投稿的图像加上了角标。同时因为咕咕机采用的是 WiFi 打印，为了减小文件体积，POST 数据前对图片尺寸进行缩小。

from pymobird import Content
from pymobird import Content

bird = SimplePymobird(appkey, device_id, user_id)
content = Content()
content.add_text('【{}】'.format(uname)) # 用户名
content.add_text(time.strftime('%Y-%m-%d %H:%M',time.gmtime(int(day)))) # 日期
content.add_text('https://t.bilibili.com/{}'.format(_id)) # 链接
content.add_text(msg) # 文字内容

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
img = Image.open('peitu.jpg')
img.thumbnail((400, 400), Image.ANTIALIAS)
font = ImageFont.truetype('SourceHanSansCN-Regular.otf', 22)
draw = ImageDraw.Draw(img)
draw.rectangle(
 (268, 15, 368, 47), fill=(250, 115, 150), outline=(250, 140, 160))
draw.text((274, 14), '投稿视频', '#FFFFFF', font=font)
img.save('peitu.png', 'PNG')
content.add_image('peitu.png')
result = bird.print_multi_part_content(content)

Crontab 定时任务

开 SSH 把脚本扔进富有历史感的树莓派。

crontab -e

*/5 * * * * python3 bilibili_fubuki.py

完整代码

#!/usr/bin/python
## -*- coding: utf-8 -*-

import json
import os
import re
import requests
import sqlite3
import time

## bilibili
uname = '白上吹雪 Official'
uid = '332704117'

## memobird
appkey = ''
device_id = ''
user_id = ''

headers = {
 'User-Agent':
 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0',
 'Accept': 'application/json, text/plain, */*',
 'Accept-Language':
 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',
 'Origin': 'https://space.bilibili.com',
 'DNT': '1',
 'Connection': 'keep-alive',
 'Referer': 'https://space.bilibili.com/',
}

newfile = not os.path.exists('bilibili_{}.sqlite'.format(uname))
db = sqlite3.connect('bilibili_{}.sqlite'.format(uname), isolation_level=None)
cur = db.cursor()

cur.execute('''
CREATE TABLE
IF
 NOT EXISTS {} (
 day VARCHAR,
 _id VARCHAR PRIMARY KEY UNIQUE,
 msg VARCHAR,
 pic BLOB,
 title VARCHAR);'''.format(uname))

if newfile:
 cur.execute('''INSERT INTO {} VALUES ( ?, ?, ?, ?, ? );'''.format(uname),
 (None, '0', '1', None, None))


def bili_pic(link):
 file = requests.get(link, headers=headers)
 return file.content


def main():
 params = (
 ('visitor_uid', '0'),
 ('host_uid', '{}'.format(uid)),
 ('offset_dynamic_id', '0'),
 )

 response = requests.get(
 'https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history',
 headers=headers,
 params=params)
 result = json.loads(response.content)
 if result.get('code') != 0:
 print(result.get('message'))
 return False

 for card in result['data']['cards']:
 card_time = card['desc']['timestamp']
 card_id = card['desc']['dynamic_id_str']
 card_type = card['desc']['type']
 data = json.loads(card['card'])
 if card_type == 8:
 title = data['title']
 pic = data['pic']
 text = data['dynamic']
 elif card_type == 4:
 title = None
 pic = None
 text = data['item']['content']
 elif card_type == 2:
 title = None
 if data['item'].get('pictures'):
 pic = data['item']['pictures'][0]['img_src']
 text = data['item']['description']
 elif card_type == 1:
 title = None
 pic = None
 text = data['item']['content']
 else:
 print(card_time, card_id, card_type)
 continue

 img = bili_pic(pic) if pic else None
 cur.execute(
 '''INSERT OR REPLACE INTO {} VALUES ( ?, ?, ?, ?, ? );'''.format(
 uname), (card_time, card_id, text, img, title))

 new = cur.execute(
 '''SELECT COUNT(_id) FROM {};'''.format(uname)).fetchone()
 old = cur.execute(
 '''SELECT msg FROM {} WHERE _id = 0;'''.format(uname)).fetchone()

 if int(new[0]) == int(old[0]):
 return False
 cur.execute('''UPDATE {} SET msg = ? WHERE _id = 0'''.format(uname),
 (str(new[0]), ))

 limit = int(new[0]) - int(old[0])
 if limit < 0:
 return False

 limit = limit if limit < 1 else 1

 from pymobird import Content
 from pymobird import SimplePymobird
 bird = SimplePymobird(ak=appkey, device_id=device_id, user_id=user_id)
 data = cur.execute(
 '''SELECT day, _id, msg, pic, title FROM {} ORDER BY _id DESC LIMIT {};'''
 .format(uname, limit)).fetchall()
 for dynamic in data[::-1]:
 day, _id, msg, pic, title = dynamic
 content = Content()
 content.add_text('【{}】'.format(uname))
 content.add_text(time.strftime('%Y-%m-%d %H:%M',time.gmtime(int(day))))
 content.add_text('https://t.bilibili.com/{}'.format(_id))
 content.add_text(msg)
 if pic:
 with open('{}.jpg'.format(uname), 'wb') as f:
 f.write(pic)
 img = Image.open('{}.jpg'.format(uname))
 img.thumbnail((400, 400), Image.ANTIALIAS)
 if title:
 from PIL import Image
 from PIL import ImageDraw
 from PIL import ImageFont
 content.add_text(title)
 font = ImageFont.truetype('SourceHanSansCN-Regular.otf', 22)
 draw = ImageDraw.Draw(img)
 draw.rectangle((268, 15, 368, 47),
 fill=(250, 115, 150),
 outline=(250, 140, 160))
 draw.text((274, 14), '投稿视频', '#FFFFFF', font=font)
 img.save('{}.png'.format(uname), 'PNG')
 content.add_image('{}.png'.format(uname))
 result = bird.print_multi_part_content(content)
 print(result)
 time.sleep(5)


if __name__ == '__main__':
 main()

EOF

哔哩哔哩下载工具二

Tue, 30 Apr 2019 00:00:00 +0000

主要解决一些之前遇到的坑，填一些留下的 TODO。

Vegas 不支持 HEVC 编码

思路很简单，对下载下来的m4s先读一遍编码，看是不是 HEVC 格式的，如果是就在转码的时候用libx264编码，不是就粗暴的 copy 视频流。

暂时不打算加上判断其他视频流格式的代码，遇到再说。

通过 ffprobe 判断编码

因为之前很少接触视频转码，也没什么机会用 ffmpeg。在判断 HEVC 编码这一步的时候，想着用类似ffmpeg -args | find "stream"的方式来取得视频编码。

可能是环境问题，没成功，而且还要另写正则匹配文本有些麻烦。查了一下改用 ffprobe。

ffprobe.exe -v error -select_streams v:0 -show_entries stream=codec_name
-of default=nokey=1:noprint_wrappers=1 v.m4s » ./t.txt

ffmpeg 合并 flv

ffmpeg 的问题主要出现在合并 flv 上，dash 视频倒没有什么问题。

采用-f concat -i file.list的方式合并遇到了路径问题。因为听取了建议“下载的文件最好单独放个目录，直接下在脚本根目录就会很乱”。

所有的文件都下载在了子文件夹里，比如./down。在下载 flv 分段的时候，文件的目录结构就类似：

.. ffmpeg.exe /down /down/file.list /down/part1.flv /down/part2.flv

ffmpeg 的命令写成：

ffmpeg -safe 0 -hide_banner -f concat -i ./down/file.list -c copy ./down/finish.mp4

问题来了，file.list 里该怎么写，我原本以为应该是：

file ‘./down/part1.flv’ file ‘./down/part2.flv’ file ‘./down/part3.flv’

然而这样 ffmpeg 会报错找不到文件，根据错误信息里提示的文件路径，应该改成

file ‘part1.flv’ file ‘part2.flv’ file ‘part3.flv’

看来 file.list 里的根目录是 file.list 所在目录。

通过子进程加速下载

音频和视频同时下载。因为原本用 os.system 的方式会阻塞，改用 subprocess.Popen 子进程，然后在 ffmpeg 合并前阻塞两个子进程，确保下载完毕再进行合并。

单个任务的话就用上面的方式，然后开启多进程同时执行多个任务。但是这样又遇到了新的问题：

尝试多进程和 pyinstaller 的坑

因为最后要打包成 exe 给其他人用，毕竟没必要让每个人都装一个 python 环境来跑脚本。

在打包过程中发现，虽然 py 脚本能够正确执行，但是打包完成的 exe 反而变成了一个 fork 炸弹，会无限的产生子进程直到让系统宕机。

如是三次之后 Google 了一下，pyinstaller 和 multiprocessing 相性不合，使用 mulitprocessing.Process 和 mulitprocessing.Pool 的代码在 pyinstaller 编译后就会出现这个问题。

给出的解决方法只适用于 python2 版本，而我用的是 python3.7，摊手。

改用 threading 绕过问题

既然不能用多进程，那就用多线程好了。

而且实际上我也的确是先用的 threading 库，遇到了问题才想的用 multiprocessing。

原因是 threading 的场合，我编译 exe 完成，测试的时候想直接关闭窗口，发现做不到。

结论而且这不算什么问题，比起 fork 炸弹要可接受的多了，而且一个下载工具，本来就没有必要在中途退出。

最后上了线程池from multiprocessing.dummy import Pool as ThreadPool，幸好这样并不会和 pyinstaller 冲突。

放弃写配置文件

计划把 ffmpeg 和 aria2c 的配置单独存文件的来着，想想又要增加代码量，而且几乎不会去动这些配置，还是作罢了。

硬编码不也挺好么.jpg

完整代码

#!/usr/bin/python
## -*- coding: utf-8 -*-

import arrow
import json
import os
import re
import requests
import subprocess

from lxml import etree
from multiprocessing.dummy import Pool as ThreadPool


today = arrow.utcnow().format('YYYY-MM-DD')
if os.path.exists('./{}'.format(today)):
 pass
else:
 os.mkdir('./{}'.format(today))

session = requests.session()
session.headers = {
 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0',
 'Accept': 'application/json, text/plain, */*',
 'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',
 'Referer': 'https://www.bilibili.com/video/av42038790?from=search&seid=4077958841119274554',
 'Origin': 'https://www.bilibili.com',
 'DNT': '1',
 'Connection': 'keep-alive',
 'Pragma': 'no-cache',
 'Cache-Control': 'no-cache',
}

with open('cookies', 'r') as f:
 cookies = f.read()
session.headers['cookie'] = cookies


def videocid(aid=42038790, part=1):
 params = (
 ('aid', aid),
 ('jsonp', 'jsonp'),
 )
 response = session.get(
 'https://api.bilibili.com/x/player/pagelist', params=params, ) # cookies=cookies)
 result = json.loads(response.content)
 cid = result['data'][part - 1]['cid']
 return cid


def videourl(aid=42038790, cid=73802454):
 params = (
 ('avid', aid),
 ('cid', cid),
 ('qn', '112'),
 ('fnver', '0'),
 ('fnval', '16'),
 ('type', ''),
 ('otype', 'json'),
 )
 response = session.get(
 'https://api.bilibili.com/x/player/playurl', params=params,) # cookies=cookies)
 result = json.loads(response.content)

 if result.get('data') is None:
 response = session.get(
 'https://api.bilibili.com/pgc/player/web/playurl', params=params,) # cookies=cookies)
 result = json.loads(response.content)
 playinfo = result.get('result')
 else:
 playinfo = result.get('data')

 if playinfo is None:
 print(aid, 'Not Found\n')
 return False

 if playinfo.get('dash'):
 aids = [x['id'] for x in playinfo['dash']['audio']]
 aurl = playinfo['dash']['audio'][aids.index(max(aids))]['baseUrl']
 vids = [x['id'] for x in playinfo['dash']['video']]
 vurl = playinfo['dash']['video'][vids.index(max(vids))]['baseUrl']

 ap = subprocess.Popen(
 '''aria2c.exe -x10 -k1M --file-allocation=none --auto-file-renaming=false "{aurl}"\
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av{aid}"\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache"\
 --header="Cache-Control: no-cache"\
 --out ./{today}/{cid}_a.m4s'''.format(today=today, aurl=aurl, aid=aid, cid=cid), shell=True)
 vp = subprocess.Popen(
 '''aria2c -x10 -k1M --file-allocation=none --auto-file-renaming=false "{vurl}"\
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av{aid}"\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache"\
 --header="Cache-Control: no-cache"\
 --out ./{today}/{cid}_v.m4s'''.format(today=today, vurl=vurl, aid=aid, cid=cid), shell=True)
 ap.wait()
 vp.wait()
 vt = subprocess.Popen(
 '''ffprobe.exe -v error -select_streams v:0 -show_entries stream=codec_name\
 -of default=nokey=1:noprint_wrappers=1\
 ./{today}/{cid}_v.m4s >> ./{today}/{cid}_t.txt'''.format(today=today, cid=cid), shell=True)
 vt.wait()
 with open('./{today}/{cid}_t.txt'.format(today=today, cid=cid), 'r') as f:
 v_type = str(f.read()).replace('\n', '')
 if v_type == 'hevc':
 fp = subprocess.Popen(
 '''ffmpeg -n -hide_banner -i ./{today}/{cid}_v.m4s -i ./{today}/{cid}_a.m4s -c:v libx264 -c:a copy\
 ./{today}/av{aid}.mp4'''.format(today=today, cid=cid, aid=aid), shell=True)
 else:
 fp = subprocess.Popen(
 '''ffmpeg -n -hide_banner -i ./{today}/{cid}_v.m4s -i ./{today}/{cid}_a.m4s -c:v copy -c:a copy\
 ./{today}/av{aid}.mp4'''.format(today=today, cid=cid, aid=aid), shell=True)

 os.remove('./{today}/{cid}_t.txt'.format(today=today, cid=cid))
 fp.wait()
 os.remove('./{today}/{cid}_a.m4s'.format(today=today, cid=cid))
 os.remove('./{today}/{cid}_v.m4s'.format(today=today, cid=cid))

 elif playinfo.get('durl'):
 vlink = [x['url'] for x in playinfo['durl']]
 with open('./{today}/{aid}_merge.txt'.format(today=today, aid=aid), 'a', encoding='utf-8') as t:
 for p, link in enumerate(vlink):
 t.write(
 """file './av{aid}_{p}.flv'\n""".format(aid=aid, p=p))

 for p, link in enumerate(vlink):
 subprocess.check_call(
 '''aria2c.exe -x10 -k1M --file-allocation=none --auto-file-renaming=false "{link}"\
 --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0"\
 --header="Accept: */*"\
 --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2"\
 --header="Referer: https://www.bilibili.com/video/av{aid}"\
 --header="Origin: https://www.bilibili.com"\
 --header="DNT: 1"\
 --header="Connection: keep-alive"\
 --header="Pragma: no-cache" --header="Cache-Control: no-cache"\
 --out ./{today}/av{aid}_{p}.flv'''.format(today=today, link=link, aid=aid, p=p), shell=True)

 fp = subprocess.Popen(
 '''ffmpeg -safe 0 -hide_banner -f concat -i ./{today}/{aid}_merge.txt -c copy\
 ./{today}/av{aid}.mp4'''.format(today=today, aid=aid), shell=True)
 fp.wait()
 os.remove('./{today}/{aid}_merge.txt'.format(today=today, aid=aid))

 for p, link in enumerate(vlink):
 os.remove(
 './{today}/av{aid}_{p}.flv'.format(today=today, aid=aid, p=p))


def main():
 pool = ThreadPool(processes=5)
 with open('down.txt', 'r') as f:
 aids = re.findall(r'av(\d+)', f.read())
 for x in aids:
 pool.apply_async(videourl, (x, videocid(x)))
 pool.close()
 pool.join()


if __name__ == '__main__':
 main()

TODO

~~部分视频的视频流是 HEVC 编码而不是 x264，Windows 读不出 MP4 缩略图，考虑要不要判断自动转码。~~
~~aria2 和 ffmpeg 的参数单独存文件方便修改，不然每次都要重新编译 exe。~~
分 P 选择和清晰度选择

EOF

哔哩哔哩下载工具

Sun, 07 Apr 2019 00:00:00 +0000

给哔哩哔哩周刊组写的下载工具。每次都要下载十几个视频，一个个手动来实在是太麻烦了。

看了下，发现下载最高清一路的视频源还是需要 cookie 认证，写不来登录，只能用 dirty 的方式读 cookie 文件了。

分析

获取视频需要知道视频的 av 号和视频 id，api 接口里分别是avid和cid，有了两者之后就可以通过 api 获得视频不同清晰度的 url 地址。

B 站现在新视频全部使用了 dash，但是老视频没有 dash，还是单个 flv，两者在 api 上返回有区别，前者是dash字段，后者是durl字段，需要判断是哪一种视频流。

对于 dash，音频和视频流分割两路，都是 m4s 格式，下载后需要合并。而 flv 根据视频时长会有多个分段文件，同样也需要合并。

代码

#!/usr/bin/python
## -*- coding: utf-8 -*-

import json
import os
import re
import requests

from lxml import etree

session = requests.session()
session.headers = {
 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0',
 'Accept': 'application/json, text/plain, */*',
 'Accept-Language': 'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2',
 # 'Referer': 'https://www.bilibili.com/video/av42038790',
 'Origin': 'https://www.bilibili.com',
 'DNT': '1',
 'Connection': 'keep-alive',
 'Pragma': 'no-cache',
 'Cache-Control': 'no-cache',
}

with open('cookies', 'r') as f:
 cookies = f.read()
session.headers["cookie"] = cookies


def videocid(aid=42038790, part=1):
 params = (
 ('aid', aid),
 ('jsonp', 'jsonp'),
 )

 response = session.get(
 'https://api.bilibili.com/x/player/pagelist', params=params, ) # cookies=cookies)
 result = json.loads(response.content)
 cid = result['data'][part - 1]['cid']
 return cid


def videourl(aid=42038790, cid=73802454):
 params = (
 ('avid', aid),
 ('cid', cid),
 ('qn', '112'),
 ('fnver', '0'),
 ('fnval', '16'),
 ('type', ''),
 ('otype', 'json'),
 )

 response = session.get(
 'https://api.bilibili.com/x/player/playurl', params=params,) # cookies=cookies)
 result = json.loads(response.content)
 if result.get('data') is None:
 response = session.get(
 'https://api.bilibili.com/pgc/player/web/playurl', params=params,) # cookies=cookies)
 result = json.loads(response.content)
 playinfo = result.get('result')
 else:
 playinfo = result.get('data')
 if playinfo is None:
 print(aid, 'Not Found\n')
 return False
 if playinfo.get('dash'):
 vids = [x['id'] for x in playinfo['dash']['video']]

 vurl = playinfo['dash']['video'][vids.index(
 max(vids))]['baseUrl']

 aids = [x['id'] for x in playinfo['dash']['audio']]

 aurl = playinfo['dash']['audio'][aids.index(
 max(aids))]['baseUrl']

 os.system('''aria2c -x10 -k1M --file-allocation=none "{}" --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0" --header="Accept: */*" --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2" --header="Referer: https://www.bilibili.com/video/av{}" --header="Origin: https://www.bilibili.com" --header="DNT: 1" --header="Connection: keep-alive" --header="Pragma: no-cache" --header="Cache-Control: no-cache" --out {}_v.m4s'''.format(vurl, aid, cid))

 os.system('''aria2c.exe -x10 -k1M --file-allocation=none "{}" --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0" --header="Accept: */*" --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2" --header="Referer: https://www.bilibili.com/video/av{}" --header="Origin: https://www.bilibili.com" --header="DNT: 1" --header="Connection: keep-alive" --header="Pragma: no-cache" --header="Cache-Control: no-cache" --out {}_a.m4s'''.format(aurl, aid, cid))

 os.system(
 '''ffmpeg -i {}_v.m4s -i {}_a.m4s -c:v copy -c:a copy -strict experimental av{}.mp4'''.format(cid, cid, aid))
 os.remove('{}_a.m4s'.format(cid))
 os.remove('{}_v.m4s'.format(cid))

 elif playinfo.get('durl'):
 vlink = [x['url'] for x in playinfo['durl']]
 print(vlink)
 for p, link in enumerate(vlink):
 os.system('''aria2c.exe -x10 -k1M --file-allocation=none "{}" --header="User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0" --header="Accept: */*" --header="Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2" --header="Referer: https://www.bilibili.com/video/av{}" --header="Origin: https://www.bilibili.com" --header="DNT: 1" --header="Connection: keep-alive" --header="Pragma: no-cache" --header="Cache-Control: no-cache" --out av{}_{}.flv'''.format(link, aid, aid, p))
 with open('merge.txt', 'a', encoding='utf-8') as t:
 for x in os.listdir('.'):
 if str(aid) in x:
 t.write("file '{}'\n".format(x))
 os.system('ffmpeg -f concat -i merge.txt -c copy av{}.mp4'.format(aid))
 os.remove('merge.txt')

 for x in os.listdir('.'):
 if x.endswith('.flv'):
 pass
 os.remove(x)


def main():
 with open('down.txt', 'r') as f:
 aids = re.findall(r'av(\d+)', f.read())
 for x in aids:
 videourl(x, videocid(x))


if __name__ == '__main__':
 main()

TODO

部分视频的视频流是 HEVC 编码而不是 x264，Windows 读不出 MP4 缩略图，考虑要不要判断自动转码。
aria2 和 ffmpeg 的参数单独存文件方便修改，不然每次都要重新编译 exe。
分 P 选择和清晰度选择

EOF

没有 KMSCON 的第一天，想他

Thu, 10 Jan 2019 00:00:00 +0000

因为树莓派用了官方系统，原本在 Arch 上利用KMSCON来回显中文字符的方式不可行了，沉痛悼念。

不会编译是罪魁祸首，而且包依赖关系看得头大，实在不想自己解决。

前情提要

因为 tty 设备不支持 CJK 字符，原本 crontab 任务只要重定向输出到KMSCON模拟的 pts 设备上就能正常显示中文，现在不得不回归起点。

选择只有两种：

研究怎么在 debian 上把KMSCON编译过去
研究怎么在图形界面输出工作用脚本的日志

然后KMSCON的编译依赖实在有点多，在 debian 内的包名又都不一样。本来就只会按照教程 ./configure、make、make install三步走的我实在是应付不来。

结果只能当KMSCON从来不存在，在图形界面寻找解决办法。

变通法

搜索之后发现的确有从终端弹图形界面的方式，只需要指定显示设备就行了：

DISPLAY=:0.0 command

因为我的目的只是需要一个终端窗口，所以：

> crontab -e
---
@reboot sleep 30 && DISPLAY=:0.0 /usr/bin/lxterminal

这样便会在系统启动之后自动启动一个终端窗口，分配一个 pts 的设备，因为是第一个终端窗口所以一定是 pts/0

再把剩下的定时脚本输出全部重定向到 /dev/pts/0 就行了

EOF

感觉还是会有回到 Arch 的一天，Arch 真香。

微博信息流广告抓取

Sat, 05 Jan 2019 00:00:00 +0000

微博注册了个小号，为了看看都是什么牛鬼蛇神在微博里推送信息流广告，尝试抓取一下。

虽然有YAWF（Yet Another Weibo Filter）这样好用的脚本可以屏蔽广告，但屏蔽了就看不到了。

找到 API 接口

F12 切换到 Network，在首页刷新页面，筛选捕捉到 api 接口https://weibo.com/aj/mblog/fsearch。

新建标签页访问，去掉不必要的参数（包括一堆用来指定上下文区间和已读分界线的 id），只留下必要的部分。

然后直接上代码开始爬取内容：

headers = {
 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:64.0) Gecko/20100101 Firefox/64.0',
 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
 'Accept-Language': 'en-US,en;q=0.5',
 'DNT': '1',
 'Connection': 'keep-alive',
 'Upgrade-Insecure-Requests': '1',
 'Cache-Control': 'max-age=0',
 'Cookie': cookie
}
params = (
 ('ajwvr', '6'),
 ('pre_page', '0'),
 ('page', '1'),
 ('pagebar', '0'),
)
response = requests.get('https://weibo.com/aj/mblog/fsearch',
 headers=headers, params=params)

返回数据是 json 结构，在data字段里存放了页面内容，这里用 lxml 库解析，保存 html 文件进行下一步。

import json
from lxml import etree

result = json.loads(response.content)
html = etree.HTML(result['data'])

with open('feed.html', 'w', encoding='utf-8-sig') as f:
 f.write(etree.tostring(html, encoding='unicode'))

CSS 筛选广告内容

打开保存的 html，格式化一下代码，找到存在feedtype="ad"属性的节点（因为不是每次获取都会有信息流广告，所以可能需要获取很多次）。

然后继续往下看子节点，直到找到具体的微博链接：

获取此节点的 xpath："//div[@feedtype]//a[@action-history='rec=1']/@action-data"

结合正则表达式提取链接：

import re

html = etree.HTML(result['data'])

links = html.xpath("//div[@feedtype]//a[@action-history='rec=1']/@action-data")
for link in links:
 adver = re.findall(r'url=([^&]+)&', link)
 with open('adver.list', 'a', encoding='utf-8-sig') as f:
 f.write(str(adver)+'\n')

最后通过 crontab 设置成定时任务自动监测。

* * * * * python weibo_adver.py

高频率的连续访问可能会造成微博提示帐号异常，而且运行时间久了 cookie 也会过期，需要自动重新登录获取 cookie。

微博的自动登录轮子很多，不用自己另写。cookie 过期的判断就比较粗暴了，如果读取返回的 json 抛出异常，就可以认为是 cookie 过期造成的。

另外测试发现，不带 cookie 的 api 访问是会返回正常的 json 数据的（但不包含 html 内容）。

import os

def login(username, password):
 """somecode balabala"""
 with open('cookies','w') as f:
 f.write(cookies)

def main():
 if os.path.exists('./cookies'):
 with open('./cookies', 'r') as f:
 cookie = f.read()
 else:
 return False
 """somecode balabala"""
 response = requests.get('https://weibo.com/aj/mblog/fsearch',
 headers=headers, params=params)
 try:
 result = json.loads(response.content)
 except json.decoder.JSONDecodeError:
 login(username, password)
 return False
 """somecode balabala"""

if __name__ == "__main__":
 main()

EOF

就结果而言效果还不错，但也发现信息流广告里还会有一些关注了的博主的正常微博内容，可以考虑和自己的关注列表对比来筛除。

从零开始 Raspberry Pi

Sat, 08 Dec 2018 00:00:00 +0000

为了让吃灰的树莓派重新开始工作，这回不瞎折腾了，直接用官方系统。

安装

按照官方教程采用 NOOBS 安装，当然也可以选择用镜像安装，不论哪一种，选择 ↓

Raspbian Stretch with desktop and recommended software

安装完成后，首次进入图形界面，选择首选项中的 Raspberry Pi Configuration ，在 Interfaces 书签页启用 SSH, VNC，之后就可以不用另接键鼠了。

记得在 Localisation 书签页设定好 WiFi Country。

连接 WiFi

因为公司 WiFi 使用了 WPA-EAP 协议，树莓派不显示热点，让我一度以为树莓派不能连接此类 WiFi。后来在这篇文章的帮助下，通过修改 wpa_supplicant.conf 连接成功，但是 WiFi 列表中对应 SSID 选项为灰色不可点击，迷。

修改 /etc/wpa_supplicant/wpa_supplicant.conf

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=CN
network={
ssid="OfficeWiFiSSID"
key_mgmt=WPA-EAP
identity="username"
password="password"
}

软件更新

更换软件源，这个不多说了，国内推荐中国科学技术大学、清华大学、网易开源镜像站的镜像。

在 apt 更新前，先删除不必要的软件。反正周也是要卸载的，没必要让他们下载安装更新。

sudo apt-get remove --purge python3-pygame python-pygame scratch nuscratch claws-mail smartsim sonic-pi minecraft-pi python-minecraftpi wolfram-engine scratch bluej nodered greenfoot scratch2 libreoffice libreoffice-base libreoffice-core chromium-browser thonny python3-thonny python-sense-emu python3-sense-emu python-sense-emu-doc sense-emu-tools

sudo apt-get autoremove
sudo apt-get update
sudo apt-get dist-upgrade

卸载这部分应用后，会有一部分文件残留，通过 VNC 远程进去打开以下三个目录

/usr/share/applications/

/usr/share/raspi-ui-overrides/applications/

/usr/share/mimelnk/application/

在三个目录里找到图标显示失效的文件，删掉它们。

自动获取树莓派 IP

接下来遇到的问题是，可能是因为联网设备实在太多，公司 WiFi 分配的 IP 地址短期内是和 MAC 绑定不变的，但假如长时间未连接，重新连接就会发分配不同的 IP。

导致 SSH 记住 IP 并没有什么用，只能每次用 VNC 或者 nmap 扫描网段找到树莓派的地址。

Google 后参考这篇文章设置，让树莓派每次 IP 变动后自动发送邮件通知自己。

sudo apt-get install ssmtp mailutils

nano /etc/ssmtp/ssmtp.conf

root=youremail@gmail.com
mailhub=smtp.gmail.com:587
AuthUser=youremail@gmail.com
AuthPass=yourpassword
UseTLS=YES
UseSTARTTLS=YES
AuthMethod=LOGIN

nano /home/pi/checkip.sh

#!/bin/bash

MYIP=`ifconfig | grep -Eo 'inet (addr:)?([0-9]*\.){3}[0-9]*' | grep -Eo '([0-9]*\.){3}[0-9]*' | grep -v '127.0.0.1'`;
TIME=`date`;

LASTIPFILE='/home/pi/.last_ip_addr';
LASTIP=`cat ${LASTIPFILE}`;

if [[ ${MYIP} != ${LASTIP} ]]
then
 if [[ ${MYIP} = '' ]]
 then
 echo "LOST"
 else
 echo "Sending E-mail.."
 echo -e "Hello\n\nTimestamp = ${TIME}\nIP = ${MYIP}\n\nBye" | \
 /usr/bin/mail -s "[INFO] Raspberrypi New IP" youremail@gmail.com;
 echo ${MYIP} > ${LASTIPFILE};
 fi
else
 echo "No IP change!"
fi

chmod +x checkip.sh

crontab -e

*/30 * * * * /home/pi/checkip.sh

EOF

于是树莓派终于可以一边通电一边吃灰了。