1 安装Cursor

感觉现在主流就是cursor。之前装过，但是也没觉得太惊艳。前阵看到有人用，感觉还行，比自己去查GPT效率高一些。

首先还是下载。

之后的界面很像VSCode

一定要打开文件夹，此时才会出现agent。

里面有5种模式，好像还是挺牛的。。。

2 python开发

原始的代码很简单，最简单的一个python。

for i in range(10):
    print(i)

在agent中输入指令

拓展这个代码，运行后有一个界面，界面中有个飞机飞过。

一番思考过后。

直接就给了新程序。

据说cursor目前最强的领域就是python，或者是web领域。

3 嵌入式开发

最后还是要回到嵌入式开发，正好手上有一个高通的RB5，先试试。

很快生成了代码，关键是真的可以用。。。

"""
Qualcomm RB5 开发板 LED 闪烁控制程序

通过 USB 连接（ADB）控制板载 LED。
默认使用 green LED，可通过命令行参数切换颜色。

用法:
    python rb5_led_blink.py
    python rb5_led_blink.py --led red --interval 0.3
    python rb5_led_blink.py --list
"""

from __future__ import annotations

import argparse
import shutil
import subprocess
import sys
import time


DEFAULT_LEDS = ("green", "red", "blue")
DEFAULT_INTERVAL = 0.5


class RB5LedController:
    def __init__(self, device: str | None = None):
        self.adb = shutil.which("adb")
        if not self.adb:
            raise RuntimeError("未找到 adb，请安装 Android Platform Tools 并加入 PATH")

        self.device = device
        self._ensure_device()
        self._ensure_root()

    def _adb_base(self) -> list[str]:
        cmd = [self.adb]
        if self.device:
            cmd.extend(["-s", self.device])
        return cmd

    def _run(self, shell_cmd: str, check: bool = True) -> subprocess.CompletedProcess[str]:
        cmd = self._adb_base() + ["shell", shell_cmd]
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
        )
        if check and result.returncode != 0:
            stderr = result.stderr.strip() or result.stdout.strip()
            raise RuntimeError(f"ADB 命令失败: {shell_cmd}\n{stderr}")
        return result

    def _ensure_device(self) -> None:
        result = subprocess.run(
            self._adb_base() + ["devices"],
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            check=True,
        )
        lines = [
            line.strip()
            for line in result.stdout.splitlines()
            if line.strip() and not line.startswith("List of devices")
        ]
        online = [line for line in lines if line.endswith("\tdevice")]

        if not online:
            raise RuntimeError("未检测到 RB5 设备，请确认 USB 已连接且 adb devices 可见")

        if self.device is None:
            self.device = online[0].split("\t", 1)[0]
        elif not any(line.startswith(f"{self.device}\tdevice") for line in online):
            raise RuntimeError(f"指定设备 {self.device} 不在线")

    def _ensure_root(self) -> None:
        subprocess.run(
            self._adb_base() + ["root"],
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
        )
        time.sleep(0.5)
        result = self._run("id")
        if "uid=0(root)" not in result.stdout:
            raise RuntimeError("无法获取 root 权限，LED 控制需要 adb root")

    def list_leds(self) -> list[str]:
        result = self._run("ls /sys/class/leds/")
        return sorted(name for name in result.stdout.split() if name and name != "mmc2::")

    def prepare_led(self, led: str) -> None:
        available = self.list_leds()
        if led not in available:
            raise ValueError(f"LED '{led}' 不存在，可用: {', '.join(available)}")

        base = f"/sys/class/leds/{led}"
        self._run(f"echo none > {base}/trigger")
        self._run(f"echo 0 > {base}/brightness")

    def set_brightness(self, led: str, value: int) -> None:
        self._run(f"echo {value} > /sys/class/leds/{led}/brightness")

    def blink(self, led: str, interval: float, count: int | None = None) -> None:
        self.prepare_led(led)
        print(f"设备: {self.device}")
        print(f"LED: {led}")
        print(f"间隔: {interval}s")
        print("按 Ctrl+C 停止\n")

        toggled = 0
        state = False
        try:
            while count is None or toggled < count:
                state = not state
                self.set_brightness(led, 255 if state else 0)
                print(f"[{'ON ' if state else 'OFF'}] {time.strftime('%H:%M:%S')}")
                toggled += 1
                time.sleep(interval)
        except KeyboardInterrupt:
            print("\n停止闪烁")
        finally:
            self.set_brightness(led, 0)


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Qualcomm RB5 LED 闪烁控制")
    parser.add_argument(
        "--led",
        choices=DEFAULT_LEDS,
        default="green",
        help="要控制的 LED 颜色（默认: green）",
    )
    parser.add_argument(
        "--interval",
        type=float,
        default=DEFAULT_INTERVAL,
        help="闪烁间隔，单位秒（默认: 0.5）",
    )
    parser.add_argument(
        "--count",
        type=int,
        default=None,
        help="闪烁次数，默认无限循环",
    )
    parser.add_argument(
        "--device",
        default=None,
        help="ADB 设备序列号，默认使用第一个在线设备",
    )
    parser.add_argument(
        "--list",
        action="store_true",
        help="列出板载 LED 后退出",
    )
    return parser.parse_args()


def main() -> int:
    args = parse_args()

    try:
        controller = RB5LedController(device=args.device)
    except RuntimeError as exc:
        print(f"错误: {exc}", file=sys.stderr)
        return 1

    if args.list:
        leds = controller.list_leds()
        print("可用 LED:")
        for name in leds:
            print(f"  - {name}")
        return 0

    if args.interval <= 0:
        print("错误: --interval 必须大于 0", file=sys.stderr)
        return 1

    try:
        controller.blink(args.led, args.interval, args.count)
    except ValueError as exc:
        print(f"错误: {exc}", file=sys.stderr)
        return 1
    except RuntimeError as exc:
        print(f"错误: {exc}", file=sys.stderr)
        return 1

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

大概看了一下，就是直接处理sys/class/leds节点，关于这部分，我之前还专门写过。

之后运行生成的脚本。

也是能直接亮。不错啊。

4 Cursor + Deepseek API

不过Cursor的token据说还是太贵了，就算开了会员，也烧不了多少次。说是要引入deepseek接口现在性价比才是最高的。

不过配置了API，说不是pro会员不能切换模型。怎么尝试也不能切换。算了，拉几把倒。。。

5 VSCode + RooCode + Deepseek

又查了一下，说是这一套可以。RooCode还是VSCode的插件，这就更方便了。

配置很简单，试了一下能用，效果还行。。。

看了一下模型，用的是reasoner。

执行了可能三个任务，花了不到1毛钱。