两头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的关键点匹配**（比如追踪多人运动时，防止关键点"跳错人"）。  
- **网约车派单**（让司机接最近的单）。  
- **工作任务分配**（谁做哪件事效率最高）。  

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

【知识点】​​匈牙利算法的计算过程示例

的问题：

## 1. OpenPose的输入和输出形状

### 输入形状：
```cpp
// 从 src/openpose/net/netCaffe.cpp:218 可以看到
if (inputData.getNumberDimensions() != 4 || inputData.getSize(1) != 3)
    error("The Array inputData must have 4 dimensions: [batch size, 3 (RGB), height, width].");
```

**输入张量形状**: `[batch_size, 3, height, width]`
- `batch_size`: 批次大小，通常为1
- `3`: RGB三通道
- `height, width`: 图像的高度和宽度



### 输出形状：
```cpp
// 从文档 doc/advanced/heatmap_output.md:66 可以看到
assert x[0] == 3 # First parameter saves the number of dimensions (18x300x500 = 3 dimensions)
shape_x = x[1:1+int(x[0])]
assert shape_x[0] == 18 # Size of the first dimension  
assert shape_x[1] == 300 # Size of the second dimension
assert shape_x[2] == 500 # Size of the third dimension
```

**输出热图形状**: `[num_channels, height, width]`
- 对于BODY_25模型: `[78, H/8, W/8]` (26个关键点热图 + 52个PAF通道)
- 对于COCO_18模型: `[57, H/8, W/8]` (19个关键点热图 + 38个PAF通道)

## 2. OpenPose的网络结构

### 主干网络（基于VGG）：
```prototxt
# 从 models/pose/body_25/pose_deploy.prototxt 可以看到
input: "image"
input_dim: 1  # batch size
input_dim: 3  # RGB channels  
input_dim: 16 # height (runtime defined)
input_dim: 16 # width (runtime defined)

# VGG前几层
conv1_1 -> relu1_1 -> conv1_2 -> relu1_2 -> pool1_stage1
conv2_1 -> relu2_1 -> conv2_2 -> relu2_2 -> pool2_stage1  
conv3_1 -> relu3_1 -> conv3_2 -> relu3_2 -> conv3_3 -> relu3_3 -> conv3_4 -> relu3_4 -> pool3_stage1
conv4_1 -> relu4_1 -> conv4_2 -> relu4_2 -> conv4_3_CPM -> relu4_3_CPM -> conv4_4_CPM -> relu4_4_CPM
```

### 多阶段细化结构：
```cpp
// Stage 1: 初始预测
// Stage 2-6: 迭代细化
// 每个stage输出:
// - 关键点热图 (Confidence Maps)  
// - 部位亲和场 (Part Affinity Fields, PAFs)
```

数学公式：
$$\mathbf{S}^t = \phi^t(\mathbf{F}, \mathbf{S}^{t-1}, \mathbf{L}^{t-1})$$
$$\mathbf{L}^t = \psi^t(\mathbf{F}, \mathbf{S}^{t-1}, \mathbf{L}^{t-1})$$

其中：
- $\mathbf{S}^t$: 第t阶段的关键点热图
- $\mathbf{L}^t$: 第t阶段的PAF
- $\mathbf{F}$: VGG特征图
- $\phi^t, \psi^t$: 第t阶段的CNN预测函数

## 3. OpenPose的后处理

### 非极大值抑制（NMS）：
```cpp
// 从 src/openpose/net/nmsBase.cpp 可以看到NMS的实现
// 找到热图中的局部最大值点作为关键点候选
```

### 部位连接算法：
```cpp
// 从 src/openpose/net/bodyPartConnectorBase.cpp:26 可以看到PAF计算
const auto vectorAToBNormX = vectorAToBX/vectorNorm;
const auto vectorAToBNormY = vectorAToBY/vectorNorm;

auto sum = T(0);
auto count = 0u;
for (auto lm = 0; lm < numberPointsInLine; lm++) {
    const auto score = (vectorAToBNormX*mapX[idx] + vectorAToBNormY*mapY[idx]);
    if (score > interThreshold) {
        sum += score;
        count++;
    }
}
```

**PAF连接分数公式**：
$$\mathit{score}_{AB} = \frac{1}{n} \sum_{u \in \mathit{line}(A,B)} \mathbf{L}(u) \cdot \frac{\overrightarrow{AB}}{|\overrightarrow{AB}|}$$

其中：
- $\mathbf{L}(u)$: 位置u的PAF向量
- $\overrightarrow{AB}$: 从关键点A到B的向量
- $n$: 线段上的采样点数

### 二部图匹配：
使用匈牙利算法进行最优关键点配对。

## 4. OpenPose的损失函数

虽然这是推理代码，但根据论文，训练时使用的损失函数是：

$$L = \sum_{t=1}^{T} \sum_{j=1}^{J} \mathbf{W} \cdot ||S_j^t(\mathbf{p}) - S_j^*(\mathbf{p})||_2^2 + \sum_{t=1}^{T} \sum_{c=1}^{C} \mathbf{W} \cdot ||L_c^t(\mathbf{p}) - L_c^*(\mathbf{p})||_2^2$$

其中：
- $S_j^t$: 第t阶段第j个关键点的预测热图
- $S_j^*$: 第j个关键点的真实热图
- $L_c^t$: 第t阶段第c个PAF的预测
- $L_c^*$: 第c个PAF的真实值
- $\mathbf{W}$: 二进制掩码，避免标注不明确区域的惩罚
- $T$: 阶段数
- $J$: 关键点数  
- $C$: PAF数

## 5. OpenPose用于摔倒检测

从源码分析，OpenPose本身不直接做摔倒检测，但提供了基础功能：

### 人体追踪：
```cpp
// 从 src/openpose/tracking/personTracker.cpp 可以看到追踪功能
class PersonTracker {
    void track(Array<float>& poseKeypoints, Array<long long>& poseIds, const Matrix& cvMatInput);
    // 使用光流法追踪关键点
};
```

### 摔倒检测的实现思路：
```python
# 基于关键点坐标实现摔倒检测的示例代码
def detect_fall(keypoints):
    # 1. 计算身体姿态角度
    hip_center = (keypoints[8] + keypoints[11]) / 2  # 髋部中心
    shoulder_center = (keypoints[2] + keypoints[5]) / 2  # 肩部中心
    
    # 2. 计算身体倾斜角度
    body_angle = math.atan2(shoulder_center[1] - hip_center[1], 
                           shoulder_center[0] - hip_center[0])
    
    # 3. 摔倒判定条件
    fall_conditions = [
        abs(body_angle) > threshold_angle,  # 身体严重倾斜
        shoulder_center[1] > hip_center[1] + height_threshold,  # 肩膀低于髋部
        motion_velocity > speed_threshold   # 快速运动
    ]
    
    return all(fall_conditions)
```

**摔倒检测算法**：

$$
\text{Fall} = \begin{cases}
1, & \text{if } |\theta| > \theta_{th} \text{ and } \Delta y > y_{th} \text{ and } v > v_{th} \\
0, & \text{otherwise}
\end{cases}
$$

其中：
- $\theta$: 身体与垂直方向的夹角
- $\Delta y$: 肩膀与髋部的垂直距离差
- $v$: 运动速度
- $\theta_{th}, y_{th}, v_{th}$: 对应的阈值

总结：OpenPose提供了强大的2D人体姿态估计能力，通过多阶段CNN网络输出关键点热图和部位亲和场，经过NMS和二部图匹配等后处理得到最终的人体关键点。虽然不直接支持摔倒检测，但可以基于其输出的关键点坐标和追踪功能来实现摔倒检测算法。

5种Agent模式

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

Fooocus Outpaint 完整处理流程

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

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

1. OpenPose的输入和输出形状

输入形状：