# searxng部署
首先需要克隆`searxng`的仓库
```bash
git clone https://github.com/searxng/searxng-docker.git
```
随后进入
```bash
cd searxng-docker
```



随后编辑`docker-compose.yaml`，将其中的`ports`部分替换为`0.0.0.0`，编辑好的文件应当是这样的

注意此处使用了[毫秒镜像](https://1ms.run/)提供的docker镜像服务
```yaml
version: "3.7"

services:
  redis:
    container_name: redis
    image: docker.1ms.run/valkey/valkey:8-alpine
    command: valkey-server --save 30 1 --loglevel warning
    restart: unless-stopped
    networks:
      - searxng
    volumes:
      - valkey-data2:/data
    cap_drop:
      - ALL
    cap_add:
      - SETGID
      - SETUID
      - DAC_OVERRIDE
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

  searxng:
    container_name: searxng
    image: docker.1ms.run/searxng/searxng:latest
    restart: unless-stopped
    networks:
      - searxng
    ports:
      - "0.0.0.0:8080:8080"
    volumes:
      - ./searxng:/etc/searxng:rw
    environment:
      - SEARXNG_BASE_URL=https://${SEARXNG_HOSTNAME:-localhost}/
      - UWSGI_WORKERS=${SEARXNG_UWSGI_WORKERS:-4}
      - UWSGI_THREADS=${SEARXNG_UWSGI_THREADS:-4}
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETGID
      - SETUID
      - DAC_OVERRIDE
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

networks:
  searxng:

volumes:
  caddy-data:
  caddy-config:
  valkey-data2:
```
然后在`.env`文件中增加一行配置url，注意该文件是隐藏的
```env
SEARXNG_HOSTNAME=localhost:8080/
```
随后编辑`searxng`文件夹下的`settings.yml`，在终端中进入`searxng`文件夹
```bash
cd searxng
```
随后创建一个密钥（命令来自于[Kaku的个人博客](https://www.kakunet.top/2024/12/04/SearchXNG%E9%83%A8%E7%BD%B2%E6%8C%87%E5%8D%97/)）
```bash
sed -i "s|ultrasecretkey|$(openssl rand -hex 32)|g" searxng/settings.yml
```
然后编辑`settings.yml`，使它应当是这个样子，这个配置只启用了必应搜索引擎
```yml
# see https://docs.searxng.org/admin/settings/settings.html#settings-use-default-settings
use_default_settings:
  engines:
    keep_only:
      - bing
server:
  # base_url is defined in the SEARXNG_BASE_URL environment variable, see .env and docker-compose.yml
  secret_key: "<这一行不要动>"  # change this!
  limiter: false  # can be disabled for a private instance
  image_proxy: true
ui:
  static_use_hash: true
redis:
  url: redis://redis:6379/0
search:
  formats:
    - html
    - json
engines:
  - name: bing
    disabled: false
```

使用`docker compose`命令启动容器
```
sudo docker compose up -d
```
这里目的是创建容器，创建成功后它是运行不起来的，把他关闭
```
sudo docker stop searxng
```
创建一个`uwsgi.ini`文件
```
touch uwsgi.ini
```
编辑它，内容为
```ini

[uwsgi]
# Who will run the code
uid = searxng
gid = searxng

# Number of workers (usually CPU count)
workers = %k
threads = 4

# The right granted on the created socket
chmod-socket = 666

# Plugin to use and interpreter config
single-interpreter = true
master = true
plugin = python3
lazy-apps = true
enable-threads = 4

# Module to import
module = searx.webapp

# Virtualenv and python path
pythonpath = /usr/local/searxng/
chdir = /usr/local/searxng/searx/

# automatically set processes name to something meaningful
auto-procname = true

# Disable request logging for privacy
disable-logging = true
log-5xx = true

# Set the max size of a request (request-body excluded)
buffer-size = 8192

# No keep alive
# See https://github.com/searx/searx-docker/issues/24
add-header = Connection: close

# uwsgi serves the static files
# expires set to one year since there are hashes
static-map = /static=/usr/local/searxng/searx/static
static-expires = /* 31557600
static-gzip-all = True
offload-threads = 4

# Cache
cache2 = name=searxngcache,items=2000,blocks=2000,blocksize=4096,bitmap=1
```

将它复制到docker容器内
```bash
sudo docker cp uwsgi.ini searxng:/etc/uwsgi
```
然后重新启动docker容器
```
sudo docker compose up -d
```
searxng 服务就运行成功了

# 在open-webui中连接searxng
来到管理员面版，转到`设置-联网搜索`，启用它，并选择联网搜索引擎为`searxng`

![image.png](/static/img/548b93ad93e80480bed488608f507914.image.webp)

将`Searxng搜索URL`设置为
```url
http://172.17.0.1:8080/search?safesearch=0&q=<query>&safesearch=0
```
其中的`172.17.0.1`是docker容器宿主机的默认IP地址。点击`保存`按钮后，转到`设置-界面`

![image.png](/static/img/1e71acc73fd83918e1c7b6c102366bf3.image.webp)

将这里的`外部模型`改为除了R1之外的其他模型。这个模型是用于生成搜索关键词的，生成速度需要比较快，所以R1是不合适的。这里选用了硅基流动的免费小模型，速度快还不收钱，任君选择

![image.png](/static/img/5556df34a0abad34046db0ea4f44d17d.image.webp)

再点击右下角的`保存`按钮，联网搜索就配置完成了。在主界面点亮`联网搜索`即可启用

![image.png](/static/img/8950e49de032f9d462a208a6291f11b2.image.webp)

部署searxng以启用open-webui的联网搜索

# 通过Docker安装open-webui
用Docker安装只需要一行命令
```bash
docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
```
其中的`3000`可以改成任何不冲突的端口



由于是部署在服务器上的，服务器自然没有浏览器，因此需要配置`nginx`启用反向代理，然后用浏览器访问
```nginx
server {
    listen 443 ssl;
    server_name <域名>;

    # SSL 证书配置（请确认证书包含子域名）
    ssl_certificate <SSL证书地址>;
    ssl_certificate_key <SSL私钥地址>;

    # SSL 安全配置
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers off;

    # 反向代理设置
    location / {
        proxy_pass http://127.0.0.1:<端口号，按照上文设置的话是3000>;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket支持
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';

        # 超时设置（可选）
        proxy_connect_timeout 6000s;
        proxy_send_timeout 6000s;
        proxy_read_timeout 6000s;
    }
}
```
随后访问`https://<上面设置的域名>`即可访问面板，初次使用需要注册，第一个账号自动成为管理员账户

需要注意的是，初次登录会存在“OI”结束后白屏的情况，这是因为默认的OpenAI API与LLama API处于开启状态。这时不能气馁，多次刷新页面，有小概率能成功进入。进入后来到管理员面版

![image.png](/static/img/89c8757cba20d540c2a663214cb64fa7.image.webp)

来到`设置-外部链接`，将两个API的按钮都关掉即可正常登录（这里打开是因为后面部署了模型）

![image.png](/static/img/31ada4bf5ffa8761439371aea8cb14a6.image.webp)

# 使用API访问DeepSeek R1
首先需要拿到一个API和密钥，此处不妨使用硅基流动的服务：[跳转硅基流动账户注册](https://cloud.siliconflow.cn/i/FngeZEAX)

使用我的邀请码`FngeZEAX`注册后可以获得14元的免费额度。注册完成后来到`API密钥`页面，点击新建密钥

![image.png](/static/img/ce82e0d7842f8cd1946f8f6fca1e8e7c.image.webp)

复制密钥，然后回到open-webui的管理员页面，转到`函数`，然后新建函数

![image.png](/static/img/d17ceea0d89da6e9fb0ae0f73ecdfb63.image.webp)

编辑函数文件（来自[open-webui社区](https://openwebui.com/f/zgccrui/deepseek_r1)）
```python
"""
title: DeepSeek R1
author: zgccrui
description: 在OpwenWebUI中显示DeepSeek R1模型的思维链 - 仅支持0.5.6及以上版本
version: 1.2.6
licence: MIT
"""

import json
import httpx
import re
from typing import AsyncGenerator, Callable, Awaitable
from pydantic import BaseModel, Field
import asyncio


class Pipe:
    class Valves(BaseModel):
        DEEPSEEK_API_BASE_URL: str = Field(
            default="https://api.siliconflow.cn/v1",
            description="DeepSeek API的基础请求地址",
        )
        DEEPSEEK_API_KEY: str = Field(
            default="<刚刚注册的API密钥>",
            description="用于身份验证的DeepSeek API密钥，可从控制台获取",
        )
        DEEPSEEK_API_MODEL: str = Field(
            default="deepseek-ai/DeepSeek-R1",
            description="API请求的模型名称，默认为 deepseek-reasoner ",
        )

    def __init__(self):
        self.valves = self.Valves()
        self.data_prefix = "data: "
        self.thinking = -1  # -1:未开始 0:思考中 1:已回答
        self.emitter = None

    def pipes(self):
        return [
            {
                "id": self.valves.DEEPSEEK_API_MODEL,
                "name": self.valves.DEEPSEEK_API_MODEL,
            }
        ]

    async def pipe(
        self, body: dict, __event_emitter__: Callable[[dict], Awaitable[None]] = None
    ) -> AsyncGenerator[str, None]:
        """主处理管道（已移除缓冲）"""
        self.thinking = -1
        self.emitter = __event_emitter__

        # 验证配置
        if not self.valves.DEEPSEEK_API_KEY:
            yield json.dumps({"error": "未配置API密钥"}, ensure_ascii=False)
            return

        # 准备请求参数
        headers = {
            "Authorization": f"Bearer {self.valves.DEEPSEEK_API_KEY}",
            "Content-Type": "application/json",
        }

        try:
            # 模型ID提取
            model_id = body["model"].split(".", 1)[-1]
            payload = {**body, "model": model_id}

            # 处理消息以防止连续的相同角色
            messages = payload["messages"]
            i = 0
            while i < len(messages) - 1:
                if messages[i]["role"] == messages[i + 1]["role"]:
                    # 插入具有替代角色的占位符消息
                    alternate_role = (
                        "assistant" if messages[i]["role"] == "user" else "user"
                    )
                    messages.insert(
                        i + 1,
                        {"role": alternate_role, "content": "[Unfinished thinking]"},
                    )
                i += 1

            # yield json.dumps(payload, ensure_ascii=False)

            # 发起API请求
            async with httpx.AsyncClient(http2=True) as client:
                async with client.stream(
                    "POST",
                    f"{self.valves.DEEPSEEK_API_BASE_URL}/chat/completions",
                    json=payload,
                    headers=headers,
                    timeout=300,
                ) as response:
                    # 错误处理
                    if response.status_code != 200:
                        error = await response.aread()
                        yield self._format_error(response.status_code, error)
                        return

                    # 流式处理响应
                    async for line in response.aiter_lines():
                        if not line.startswith(self.data_prefix):
                            continue

                        # 截取 JSON 字符串
                        json_str = line[len(self.data_prefix) :]

                        try:
                            data = json.loads(json_str)
                        except json.JSONDecodeError as e:
                            # 格式化错误信息，这里传入错误类型和详细原因（包括出错内容和异常信息）
                            error_detail = f"解析失败 - 内容：{json_str}，原因：{e}"
                            yield self._format_error("JSONDecodeError", error_detail)
                            return

                        choice = data.get("choices", [{}])[0]

                        # 结束条件判断
                        if choice.get("finish_reason"):
                            return

                        # 状态机处理
                        state_output = await self._update_thinking_state(
                            choice.get("delta", {})
                        )
                        if state_output:
                            yield state_output  # 直接发送状态标记
                            if state_output == "<think>":
                                yield "\n"

                        # 内容处理并立即发送
                        content = self._process_content(choice["delta"])
                        if content:
                            if content.startswith("<think>"):
                                match = re.match(r"^<think>", content)
                                if match:
                                    content = re.sub(r"^<think>", "", content)
                                    yield "<think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"

                            elif content.startswith("</think>"):
                                match = re.match(r"^</think>", content)
                                if match:
                                    content = re.sub(r"^</think>", "", content)
                                    yield "</think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"
                            yield content

        except Exception as e:
            yield self._format_exception(e)

    async def _update_thinking_state(self, delta: dict) -> str:
        """更新思考状态机（简化版）"""
        state_output = ""

        # 状态转换：未开始 -> 思考中
        if self.thinking == -1 and delta.get("reasoning_content"):
            self.thinking = 0
            state_output = "<think>"

        # 状态转换：思考中 -> 已回答
        elif (
            self.thinking == 0
            and not delta.get("reasoning_content")
            and delta.get("content")
        ):
            self.thinking = 1
            state_output = "\n</think>\n\n"

        return state_output

    def _process_content(self, delta: dict) -> str:
        """直接返回处理后的内容"""
        return delta.get("reasoning_content", "") or delta.get("content", "")

    def _format_error(self, status_code: int, error: bytes) -> str:
        """错误格式化保持不变"""
        try:
            err_msg = json.loads(error).get("message", error.decode(errors="ignore"))[
                :200
            ]
        except:
            err_msg = error.decode(errors="ignore")[:200]
        return json.dumps(
            {"error": f"HTTP {status_code}: {err_msg}"}, ensure_ascii=False
        )

    def _format_exception(self, e: Exception) -> str:
        """异常格式化保持不变"""
        err_type = type(e).__name__
        return json.dumps({"error": f"{err_type}: {str(e)}"}, ensure_ascii=False)
```

需要将`<刚刚注册的API密钥>`替换为刚刚注册的API密钥，然后点击`保存`，并启用函数

![image.png](/static/img/16a2ccefde3166be47d4e5328f800441.image.webp)

随后DeepSeek-R1就自动出现在`模型`页面中了，退出管理员面板即可与其正常对话

部署open-webui通过API使用DeepSeek R1和其他LLM

由于Minecraft基岩版发新版本后会禁止旧版本的登陆，就像这样



![image.png](/static/img/1e82ee14f34fd9fd4db223a9950fbd99.image.webp)

因此需要维护服务器的更新

# 关闭旧服务端并备份数据
如果像我一样使用`screen`命令运行服务器的话，就可以使用下面的命令
```shell
screen -r mc
```
其中`mc`是服务端的名称，如果忘记的话可以使用下面的命令查看
```shell
screen -ls
```
期望中会输出这样的结果
```shell
There are screens on:
	3235882.mc	(10/26/2024 01:04:27 AM)	(Detached)
1 Sockets in /run/screen/S-ecs-user.
```
进入服务端后台后输入`stop`命令安全关闭服务端，输出会像这样
```shell
stop
[2025-01-17 20:07:01:040 INFO] Server stop requested.
[2025-01-17 20:07:01:130 INFO] Stopping server...
Quit correctly
```
关闭服务端后`ls`能看到目录的结构
```shell
allowlist.json                 Dedicated_Server.txt        MQC-121.30.1-server.zip  release-notes.txt  world_templates
bedrock_server                 definitions                 MQC-121.40.1-server.zip  resource_packs     读我.txt
bedrock-server-1.21.42.01.zip  development_behavior_packs  MQC-SERVER               server.properties
bedrock_server_how_to.html     development_resource_packs  packet-statistics.txt    treatments
behavior_packs                 development_skin_packs      permissions.json         worlds
config                         minecraftpe                 premium_cache            worlds.zip
```
其中需要备份的文件有
1. `worlds`文件夹：保存地图数据以及模组
2. `permissions.json`：保存用户权限
3. `server.properties`：保存服务端配置
4. `allowlist.json`：玩家白名单

需要注意的是`behavior_packs`和`resource_packs`是没有作用的，模组是装在`worlds`文件夹的，不需要迁移

# 配置新服务器
首先从官网下载最新的服务端，[下载链接](https://www.minecraft.net/zh-hans/download/server/bedrock)，可以选择直接`wget`下载也可以本地下载再上传到服务器

然后使用`unzip`解压
```shell
unzip bedrock-server-1.21.51.02.zip
```
解压后的目录应当是这样的
```shell
allowlist.json  bedrock-server-1.21.51.02.zip  behavior_packs  definitions       profanity_filter.wlist  resource_packs
bedrock_server  bedrock_server_how_to.html     config          permissions.json  release-notes.txt       server.properties
```

然后需要将之前服务端的数据迁移过来，使用命令（注意此时处于`mc-server-6`目录下，`mc-server-5`是要迁移的服务端）
```shell
cp -r ../mc-server-5/worlds ./
cp ../mc-server-5/permissions.json ./
cp ../mc-server-5/server.properties ./
cp ../mc-server-5/allowlist.json ./
```

# 模组卸载
基岩版小版本之间都存在模组适配存在问题，需要卸载后再启动，模组的卸载是需要手动的。进入
```shell
worlds/Bedrock level/
```
其中的目录结构是这样的
```shell
behavior_packs/  level.dat      levelname.txt    world_behavior_pack_history.json  world_resource_pack_history.json
db/              level.dat_old  resource_packs/  world_behavior_packs.json         world_resource_packs.json
```
需要操作的是`behavior_packs`目录和`world_behavior_packs.json`文件
- `behavior_packs`：放着模组的本体
- `world_behavior_packs.json`：服务端启动时从这里看要加载什么模组

由于只安装了连锁采集模组，`world_behavior_packs.json`是这样的
```json
[{"pack_id":"05a423a2-5644-fad1-7784-a6d4c369c820","version":[121,40,1]}]
```
它对应的是`worlds/Bedrock level/behavior_packs/chain_bp`目录中`manifest.json`文件的`header`属性
```shell
pack_id->uuid, version->version
```
下面贴出`manifest.json`文件

```json
{
	"format_version": 2,
	"header": {
		"name": "MQC-121.40.1-BP-SERVER",
		"uuid": "05a423a2-5644-fad1-7784-a6d4c369c820",
		"version": [121, 40, 1],
		"min_engine_version": [1, 21, 40]
	},
	"metadata": {
		"authors": ["lxhzzy"],
		"generated_with": {
			"esbuild": ["0.19.9"],
			"gulp": ["4.0.2"]
		},
		"license": "CC-BY-ND-4.0"
	},
	"modules": [
		{
			"description": "script_modules",
			"type": "script",
			"language": "javascript",
			"uuid": "b94d62b8-345a-63de-bf91-9c4aba9e2913",
			"version": [1, 0, 0],
			"entry": "index.js"
		}
	],
	"dependencies": [
		{
			"module_name": "@minecraft/server",
			"version": "1.16.0-beta"
		},
		{
			"module_name": "@minecraft/server-ui",
			"version": "1.3.0"
		},
		{
			"module_name": "@minecraft/server-admin",
			"version": "1.0.0-beta"
		}
	],
	"capabilities": ["script_eval"]
}
```
只需要把它们都删掉就好了

# 重新启动服务端
完成这一切，回到服务端根目录执行
```shell
./bedrock_server
```
就可以启动服务端愉快地玩耍啦

记一次Minecraft基岩版服务器更新

按照逻辑功能的不同，将触发器分为D触发器，JK触发器，T触发器和SR触发器。上升沿触发的触发器逻辑符号如下

![image.png](/static/img/aa75e560807f7d8e67d0ddfaa6864324.image.webp)



# D触发器
D触发器每次触发时将状态设为D，其特性表如下

![image.png](/static/img/8955188494a0f93d0bd10210723408dc.image.webp)

得到其特性方程
$$
Q^{n+1}=D
$$
与状态转换图

![image.png](/static/img/34cfa71a4d447fbf137c575e2ec1b64a.image.webp)

# JK触发器
JK触发器是功能最全面的触发器，逻辑上可以这样表述
- JK都为0时保持状态不变
- $J=0,~K=1$时将触发器置0
- $J=1,~K=0$时将触发器置1
- JK都为1时将触发器翻转

其特性表如下

![image.png](/static/img/92fe2d4ca649477b5ba2332cee487fc6.image.webp)

进而得到特性方程
$$
Q^{n+1}=J\bar{Q^n}+\bar{K}Q^n
$$
状态转换图为

![image.png](/static/img/57771f4d492c3deb65e536524c2a5172.image.webp)

# T触发器
T触发器仅提供了翻转功能。当T为0时保持状态，T为1时翻转状态

![image.png](/static/img/bd9cdb5aa9b5b61b0efdfa8f147bcd92.image.webp)

得到其特性方程
$$
Q^{n+1}=T\bar{Q_n}+\bar{T}Q^n
$$
状态图为
![image.png](/static/img/51cb30e9668017f483e3b270970dd115.image.webp)

T触发器等价于JK接在一起的JK触发器。如果T触发器的T始终接在高电平，则称为T’触发器，每经过一个时钟周期翻转一次
$$
Q^{n+1}=\bar{Q^n}
$$

# SR触发器
与SR锁存器一样，SR触发器仅具有置位和复位功能

![image.png](/static/img/54cd121b97c2f2adb6e6827f3137d306.image.webp)

使用时需要保证$SR=0$，得到其特性方程
$$
Q^{n+1}=S+\bar{R}Q^n
$$
其状态图

![image.png](/static/img/9e3dbe2db4dea0a2ae0c1b8a26778b2e.image.webp)

# D触发器构成其他触发器
用D触发器构成JK触发器只需要令
$$
D=J\bar{Q^n}+\bar{K}Q^n
$$
也就是电路

![image.png](/static/img/9a49d9ecf64633240e613ffed6674c7e.image.webp)

如果希望构成T触发器，则令
$$
D=T\bar{Q_n}+\bar{T}Q^n=T\oplus Q^n=T\odot\bar{Q^n}
$$
可以使用异或或者同或门实现

![image.png](/static/img/a477bc6942cf6e1d54475a4596edd499.image.webp)

逻辑功能触发器

555定时器可以组成脉冲的产生，整形，延时，定时电路



# 555定时器

555定时器的结构是这样的

![image.png](/static/img/36627ff7015b279c4744a5ad42edb743.image.webp)

$V_{CC}$被三个电阻分为了三段。它的功能表如下

![image.png](/static/img/f9d0d11d2731b6b396305f1d0a6aa9ff.image.webp)

如果控制电压不悬空，则比较器的参考电压就变为了
$$
\dfrac23V_{CC}\to v_{1c},\quad\dfrac13V_{CC}\to \dfrac12v_{1c}
$$
三极管的作用是为外接的RC电路提供放电通路，通常要加上一个上拉电阻使用

# 555定时器组成施密特触发电路
将阈值输入与出发输入接入信号输入，控制电压接$0.01\mu F$的滤波电容到地用于稳定比较器的参考电压

![image.png](/static/img/4387a2d1048ae67881e13f46a90065a4.image.webp)

它的正向阈值电压与负向阈值电压为
$$
V_{T+}=\dfrac23C_{CC},\quad V_{T-}=\dfrac13V_{CC}
$$
若控制电压引脚加上电压$V_R$，则
$$
V_{T+}=V_R,\quad V_{T-}=\dfrac12 V_{R}
$$

# 555定时器组成单稳态电路
嗯，这样接

![image.png](/static/img/3c6a532b08b68d5de6e6d0fc0d77b568.image.webp)

外接电阻和电容要求
$$
R_2C_2=t_w/10
$$
电路是负脉冲触发，阈值是
$$
\dfrac13V_{CC}
$$

$v_C$按指数上升到略大于$2V_{CC}/3$时，电路的输出跳为低电平，放电三极管T导通，使得电容放电。可得脉冲宽度
$$
t_w=RC\ln 3\approx 1.1RC
$$

# 555组成多谐振荡电路
嗯，这样接

![image.png](/static/img/008a20ad2c8e710014aeea49395bef44.image.webp)

初始时刻电容没有电，输出高电平。当$v_C$被充电到略大于
$$
\dfrac23V_{CC}
$$
时，$v_O$变为低电平，T导通使得电容放电。当电容放电到$v_C$略小于
$$
\dfrac13V_{CC}
$$
时，$v_O$重新翻为高电平。由此得到电容的充放电时间
$$
t_{pH}=(R_1+R_2)C\ln2\approx 0.7(R_1+R_2)C,\quad t_{pL}=R_2C\ln2\approx 0.7R_2C
$$
如果希望占空比可调则可以使用可变电阻，在不改变电阻和的情况下单独调整$R_1$