临时有效：

```
export http_proxy="http://127.0.0.1:10828"
export https_proxy="http://127.0.0.1:10828"
sudo -E apt update  # -E 保留环境变量

sudo -E apt upgrade
```

apt update proxy setting

两头USB都插电，左上角的开关打到中间是给电，打到上面是USB，打到下面是关闭电源。

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




代码功能如下：

# MSP430F5529 数字时钟

这是一个基于MSP430F5529单片机的数字时钟项目，具有实时时钟显示、闹钟功能和电容触摸按键控制。

## 功能特性

### 1. 实时时钟显示
- 显示完整的年月日时分秒
- 使用MSP430F5529内置RTC模块
- 精确的时间计时

### 2. 闹钟功能
- 可设置完整的闹钟时间（年月日时分秒）
- 闹钟触发时显示"*** ALARM ***"
- 闹钟自动在10秒后停止显示
- 可通过按键手动停止闹钟

### 3. 电容触摸控制
使用5个电容触摸按钮进行操作：
- **电容按钮1**: 进入设置模式 / 切换设置项
- **电容按钮2**: 增加当前设置值
- **电容按钮3**: 减少当前设置值  
- **电容按钮4**: 保存设置并退出 / 停止闹钟
- **电容按钮5**: 停止闹钟

### 4. 设置功能
可以设置以下12个参数：
- 时钟：年、月、日、时、分、秒
- 闹钟：年、月、日、时、分、秒

## 显示界面

LCD屏幕分为6行显示：
```
第1行: Digital Clock      (标题)
第2行: 2025-06-05          (当前日期)
第3行: 23:05:23            (当前时间)
第4行: A:2025-06-05        (闹钟日期，A表示Alarm)
第5行:   23:05:30          (闹钟时间，前面有空格对齐)
第6行: 状态信息            (设置模式/闹钟提示)
```

## 硬件要求

- MSP430F5529 LaunchPad开发板
- LCD显示屏（Dogs102x6）
- 5个电容触摸按钮（element0-element4）
- 支持背光控制

## 项目文件结构

```
disp_time_lab/
├── digital_clock.c          # 主程序文件
├── digital_clock.h          # 头文件
├── README.md               # 项目说明
├── Makefile                # 编译脚本
├── MSP-EXP430F5529_HAL/     # 硬件抽象层
│   ├── HAL_Board.c/h        # 板级支持
│   ├── HAL_Buttons.c/h      # 按钮驱动
│   └── HAL_Dogs102x6.c/h    # LCD驱动
├── F5xx_F6xx_Core_Lib/      # MSP430核心库
│   ├── HAL_PMM.c/h          # 电源管理
│   └── HAL_UCS.c/h          # 时钟系统
└── CTS/                     # 电容触摸库
    ├── CTS_Layer.c/h        # 触摸检测
    └── structure.c/h        # 触摸元素定义
```

## 使用说明

### 正常模式
- 屏幕显示当前时间和闹钟设置时间
- 按电容按钮1进入设置模式

### 设置模式
1. 按电容按钮1进入设置，从"设置时钟年"开始
2. 继续按电容按钮1可依次切换设置项：
   - Set Clk Year → Set Clk Month → Set Clk Day → Set Clk Hour → Set Clk Min → Set Clk Sec
   - Set Alm Year → Set Alm Month → Set Alm Day → Set Alm Hour → Set Alm Min → Set Alm Sec
3. 按电容按钮2增加当前值，按电容按钮3减少当前值
4. 按电容按钮4保存所有设置并退出设置模式

### 闹钟操作
- 当闹钟时间到达时，屏幕第6行会显示"*** ALARM ***"
- 闹钟会自动在10秒后停止显示
- 也可以按电容按钮4或5手动停止闹钟

## 烧录到开发板

### 使用Code Composer Studio：
1. 连接MSP430F5529开发板到PC
2. 在CCS中点击"Debug"按钮
3. 程序会自动编译、下载并开始调试


## 初始设置

- 初始时间：2025-06-05 23:05:20
- 初始闹钟：2025-06-05 23:05:30（测试用，启动后30秒会响闹钟）

# 代码

https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2

MSP-EXP430F5529 数字时钟，万年历，代码

Code Composer Studio CCS 工程设置，如何设置h文件查找路径？

【知识点】openai请求参数如何转为大模型的字符串？

【知识点】Qwen3对话模板是什么？（是一种转换规则）对话模板如何将openai api请求参数转为字符串？

## 5种Agent模式

---

### 一、反思模式（Reflection Pattern）：闭环优化的认知迭代  


- **工作流程**：  
  用户输入 → LLM生成初版响应 → 用户反馈 → LLM反思优化 → 迭代至满意 → 返回终版

---



### 二、工具使用模式（Tool Use Pattern）：打破能力边界的连接器

- **工作流程**：  
  用户输入 → LLM解析需求 → 调用API/数据库 → 工具执行 → 整合结果生成响应


---

### 三、ReAct模式：推理与行动的动态闭环  
*强调Reasoning与Acting的循环迭代*

- **工作流程**：  
  LLM-Reason制定策略 → 工具执行 → 环境反馈 → LLM-Generate生成响应

- **突破性设计**：  
  工具执行结果会重新进入推理引擎（Reasoning Engine），触发策略动态调整。

---

### 四、规划模式（Planning Pattern）：复杂任务的全景式拆解

- **工作流程**：  
  用户需求 → Planner拆解任务树 → React Agent分步执行 → 结果聚合 → 生成响应

- **核心优势**：  
  任务分解算法（如Tree-of-Thoughts）可处理超长逻辑链。

---

### 五、多智能体模式（Multi-agent）：AI组织的协同进化

- **工作流程**：  
  PM Agent任务分派 → DevOps/Tech Lead/SDE Agent协作执行 → 结果汇总 → 响应生成

- **颠覆性价值**：  
  类组织架构的Agent网络（微软Autogen架构）实现专业分工。
---

### 模式选择决策树
| 需求特征         | 推荐模式                |
|------------------|-------------------------|
| 需持续优化输出   | 反思模式                | 
| 需实时外部数据   | 工具使用模式            |
| 复杂决策链       | ReAct模式               |
| 百步以上任务流   | 规划模式                |
| 多领域专业协作   | 多智能体模式            |

【知识点】5种Agent模式

## Fooocus Outpaint 完整处理流程

### 1. **Canvas Expansion & Mask Creation** 画布扩展和遮罩创建
```12:15:modules/async_worker.py
def apply_outpaint(async_task, inpaint_image, inpaint_mask):
    if len(async_task.outpaint_selections) > 0:
        H, W, C = inpaint_image.shape
        if 'top' in async_task.outpaint_selections:
            inpaint_image = np.pad(inpaint_image, [[int(H * 0.3), 0], [0, 0], [0, 0]], mode='edge')
            inpaint_mask = np.pad(inpaint_mask, [[int(H * 0.3), 0], [0, 0]], mode='constant', constant_values=255)
```
- 根据用户选择的方向（top/bottom/left/right）扩展画布30%
- 使用edge模式复制边缘像素填充新区域
- 新区域的mask值设为255（完全需要重绘）



### 2. **Content-Aware Filling** 内容感知填充
```158:170:modules/inpaint_worker.py
# compute filling
if use_fill:
    self.interested_fill = fooocus_fill(self.interested_image, self.interested_mask)
```
在`fooocus_fill`函数中：
```136:147:modules/inpaint_worker.py
def fooocus_fill(image, mask):
    height, width, _ = image.shape
    mask = mask[:, :, 0]
    raw_image = image.copy()
    raw_mask = mask.copy()

    # 多尺度模糊填充算法
    for r in [11, 7, 5, 3]:
        kernel = np.ones((r, r), dtype=np.uint8)
        dilated_mask = cv2.dilate(mask, kernel, iterations=1)
        blurred_image = box_blur(image, r)
        image = np.where(dilated_mask[..., None] > 128, blurred_image, image)
        mask = dilated_mask
```

### 3. **VAE Inpaint Encoding** VAE修复编码
```177:189:modules/core.py
def encode_vae_inpaint(vae, pixels, mask):
    # 预处理mask
    w = mask.round()[..., None]
    pixels = pixels * (1 - w) + 0.5 * w  # 用0.5替换masked区域
    
    # VAE编码
    latent = vae.encode(pixels)
    B, C, H, W = latent.shape
    
    # 处理latent mask
    latent_mask = mask[:, None, :, :]
    latent_mask = torch.nn.functional.interpolate(latent_mask, size=(H * 8, W * 8), mode="bilinear").round()
    latent_mask = torch.nn.functional.max_pool2d(latent_mask, (8, 8)).round().to(latent)
```

### 4. **Inpaint Head Injection** 修复头部注入
```194:218:modules/inpaint_worker.py
def patch(self, inpaint_head_model_path, inpaint_latent, inpaint_latent_mask, model):
    # 加载inpaint head模型
    if inpaint_head_model is None:
        inpaint_head_model = InpaintHead()
        sd = torch.load(inpaint_head_model_path, map_location='cpu', weights_only=True)
        inpaint_head_model.load_state_dict(sd)
    
    # 特征拼接和处理
    feed = torch.cat([
        inpaint_latent_mask,
        model.model.process_latent_in(inpaint_latent)
    ], dim=1)
    
    inpaint_head_feature = inpaint_head_model(feed)
```

### 5. **Diffusion Sampling (Add Noise + Denoise)** 扩散采样（加噪+去噪）
```280:342:modules/core.py
def ksampler(model, positive, negative, latent, seed=None, steps=30, cfg=7.0, 
             sampler_name='dpmpp_2m_sde_gpu', scheduler='karras', denoise=1.0, ...):
    
    latent_image = latent["samples"]
    
    # 准备噪声（加噪过程）
    if disable_noise:
        noise = torch.zeros(latent_image.size(), ...)
    else:
        noise = ldm_patched.modules.sample.prepare_noise(latent_image, seed, batch_inds)
    
    # 扩散采样过程（去噪过程）
    samples = ldm_patched.modules.sample.sample(model,
                                                noise, steps, cfg, sampler_name, scheduler,
                                                positive, negative, latent_image,
                                                denoise=denoise, ...)
```

### 6. **Post-processing** 后处理
```254:261:modules/inpaint_worker.py
def post_process(self, img):
    a, b, c, d = self.interested_area
    content = resample_image(img, d - c, b - a)
    result = self.image.copy()
    result[a:b, c:d] = content
    result = self.color_correction(result)
    return result
```

## 总结流程：


1. **扩展画布** → 创建新区域和mask
2. **填充mask** → 使用content-aware filling算法
3. **VAE编码** → 将图像和mask编码到潜在空间
4. **加噪** → 准备噪声张量
5. **去噪** → 通过扩散采样生成新内容
6. **后处理** → 调整尺寸和颜色校正

【深度学习】Fooocus Outpaint 原理

【深度学习】Fooocus 图像变化功能（Vary）的实现原理详解

【MCP使用】大模型MCP详细底层逻辑讲解，彻底学会MCP

### **匈牙利算法是做什么的？通俗解释**
匈牙利算法（Hungarian Algorithm）是一种用来解决**"最佳分配问题"**的数学方法。它的核心任务是：**"如何用最低成本，把N个任务分配给N个人，让总成本最小？"**（或者反过来，让收益最大）。



---

### **🌰 举个栗子：外卖员送餐问题**
假设有：
- **3个外卖员**（A、B、C）  
- **3个订单**（1、2、3）  
- 每个外卖员送每个订单的**配送成本**不同：

|       | 订单1 | 订单2 | 订单3 |
|-------|-------|-------|-------|
| **A** | 5元   | 8元   | 6元   |
| **B** | 4元   | 7元   | 10元  |
| **C** | 3元   | 9元   | 8元   |

**目标**：怎么分配订单，让总配送成本最低？

---

### **🔧 匈牙利算法的解决步骤**
1. **每行减去最小值**（让每行至少有一个0）：  
   - A行最小是5 → A行减5 → `[0, 3, 1]`  
   - B行最小是4 → B行减4 → `[0, 3, 6]`  
   - C行最小是3 → C行减3 → `[0, 6, 5]`  

   新表格：
   |       | 订单1 | 订单2 | 订单3 |
   |-------|-------|-------|-------|
   | **A** | 0     | 3     | 1     |
   | **B** | 0     | 3     | 6     |
   | **C** | 0     | 6     | 5     |

2. **每列减去最小值**（让每列也至少有一个0）：  
   - 订单1列已经是 `[0, 0, 0]`（不用减）  
   - 订单2列最小是3 → 减3 → `[0, 0, 3]`  
   - 订单3列最小是1 → 减1 → `[0, 5, 4]`  

   新表格：
   |       | 订单1 | 订单2 | 订单3 |
   |-------|-------|-------|-------|
   | **A** | 0     | 0     | 0     |
   | **B** | 0     | 0     | 5     |
   | **C** | 0     | 3     | 4     |

3. **用最少的线覆盖所有0**（横线或竖线）：  
   - 画一条横线覆盖A行（因为A行全是0）  
   - 画一条竖线覆盖订单1列（因为B和C的订单1是0）  
   - 现在所有0都被覆盖了，但只用了2条线（小于3，说明还能优化）。

4. **调整数字，创造新的0**：  
   - 找到未被线覆盖的最小数字（这里是3）。  
   - 所有未被线覆盖的数字减3，被线交叉的数字加3。  
   - 调整后表格：
     |       | 订单1 | 订单2 | 订单3 |
     |-------|-------|-------|-------|
     | **A** | 3     | 0     | 0     |
     | **B** | 0     | 0     | 2     |
     | **C** | 0     | 3     | 1     |

5. **重新画线覆盖0**：  
   - 现在需要3条线才能覆盖所有0（等于人数，说明找到最优解了）。  
   - **分配方案**：  
     - A → 订单3（0元）  
     - B → 订单2（0元）  
     - C → 订单1（0元）  
     - **总成本 = 6 + 7 + 3 = 16元**（比随便分配更省钱！）

---

### **💡 通俗记忆法**
匈牙利算法就像**"相亲配对"**：
1. **先让每个人降低标准**（每行减最小值）。  
2. **再让所有对象降低标准**（每列减最小值）。  
3. **用最少的"红线"覆盖所有可能的配对**（画线覆盖0）。  
4. **如果配对不够，就调整标准**（加减数字创造新0）。  
5. **最终找到最合适的CP**（最优分配方案）！

---

### **🚀 实际应用**
- **OpenPose的关键点匹配**（比如追踪多人运动时，防止关键点"跳错人"）。  
- **网约车派单**（让司机接最近的单）。  
- **工作任务分配**（谁做哪件事效率最高）。  

简单来说，**匈牙利算法就是"用数学帮你做最划算的决策"**！

5种Agent模式

一、反思模式（Reflection Pattern）：闭环优化的认知迭代

Fooocus Outpaint 完整处理流程

1. Canvas Expansion & Mask Creation 画布扩展和遮罩创建

匈牙利算法是做什么的？通俗解释