chore: refactor code blocks

This commit is contained in:
2026-07-16 00:53:01 +08:00
parent b8e7cb33f9
commit aa14c220f7
6 changed files with 346 additions and 345 deletions
+7 -7
View File
@@ -1,9 +1,9 @@
--- ---
title: C++输入输出流的operator title: C++ 输入输出流的 operator
published: 2025-05-14 published: 2025-05-14
tags: ["C++", "IO流"] tags: ["C++", "IO流"]
category: 技术 category: 技术
description: C++输入输出流的operator description: C++ 输入输出流的 operator
--- ---
今天是朝鲜主体历114年5月14日 (喜) 今天是朝鲜主体历114年5月14日 (喜)
@@ -17,7 +17,7 @@ description: C++输入输出流的operator
```cpp ```cpp
class A { class A {
public: public:
bool operator==(const A& rhs) const; // 等价于 bool A::operator==(const A* this, const A& rhs) bool operator==(const A& rhs) const; // 等价于 bool A::operator==(const A* this, const A& rhs)
}; };
a == b; // 实际调用 a.operator==(b), 即 operator==(&a, b) a == b; // 实际调用 a.operator==(b), 即 operator==(&a, b)
@@ -30,14 +30,14 @@ a == b; // 实际调用 a.operator==(b), 即 operator==(&a, b)
```cpp ```cpp
class Person { class Person {
private: private:
std::string name; std::string name;
public: public:
friend std::ostream& operator<<(std::ostream&, const Person&); friend std::ostream& operator<<(std::ostream&, const Person&);
}; };
std::ostream& operator<<(std::ostream& os, const Person& p) { std::ostream& operator<<(std::ostream& os, const Person& p) {
os << p.name; os << p.name;
return os; return os;
} }
``` ```
+59 -59
View File
@@ -24,57 +24,57 @@ description: 高斯-约旦消元法的 Kotlin 实现
* @return 矩阵的秩 * @return 矩阵的秩
*/ */
fun computeRREF(matrix: Array<DoubleArray>): Int { fun computeRREF(matrix: Array<DoubleArray>): Int {
val rows = matrix.size val rows = matrix.size
val cols = if (rows > 0) matrix[0].size else 0 val cols = if (rows > 0) matrix[0].size else 0
var rank = 0 var rank = 0
var pivotRow = 0 var pivotRow = 0
var pivotCol = 0 var pivotCol = 0
while (pivotRow < rows && pivotCol < cols) { while (pivotRow < rows && pivotCol < cols) {
// 寻找当前列的主元 // 寻找当前列的主元
var maxRow = pivotRow var maxRow = pivotRow
for (i in pivotRow + 1..<rows) { for (i in pivotRow + 1..<rows) {
if (abs(matrix[i][pivotCol]) > abs(matrix[maxRow][pivotCol])) { if (abs(matrix[i][pivotCol]) > abs(matrix[maxRow][pivotCol])) {
maxRow = i maxRow = i
} }
} }
// 如果当前列所有元素都是0,则处理下一列 // 如果当前列所有元素都是0,则处理下一列
if (abs(matrix[maxRow][pivotCol]) < 1e-10) { if (abs(matrix[maxRow][pivotCol]) < 1e-10) {
pivotCol++ pivotCol++
continue continue
} }
// 交换行 // 交换行
if (maxRow != pivotRow) { if (maxRow != pivotRow) {
val temp = matrix[pivotRow] val temp = matrix[pivotRow]
matrix[pivotRow] = matrix[maxRow] matrix[pivotRow] = matrix[maxRow]
matrix[maxRow] = temp matrix[maxRow] = temp
} }
// 归一化主元行 // 归一化主元行
val divisor = matrix[pivotRow][pivotCol] val divisor = matrix[pivotRow][pivotCol]
for (j in pivotCol..<cols) { for (j in pivotCol..<cols) {
matrix[pivotRow][j] /= divisor matrix[pivotRow][j] /= divisor
} }
// 消元操作,使主元所在列的其他元素为0 // 消元操作,使主元所在列的其他元素为0
for (i in 0..<rows) { for (i in 0..<rows) {
if (i != pivotRow) { if (i != pivotRow) {
val factor = matrix[i][pivotCol] val factor = matrix[i][pivotCol]
for (j in pivotCol..<cols) { for (j in pivotCol..<cols) {
matrix[i][j] -= factor * matrix[pivotRow][j] matrix[i][j] -= factor * matrix[pivotRow][j]
} }
} }
} }
// 处理下一行和下一列 // 处理下一行和下一列
pivotRow++ pivotRow++
pivotCol++ pivotCol++
rank++ rank++
} }
return rank return rank
} }
``` ```
@@ -87,15 +87,15 @@ return rank
// 寻找主元 // 寻找主元
var maxRow = pivotRow var maxRow = pivotRow
for (i in pivotRow + 1 until rows) { for (i in pivotRow + 1 until rows) {
if (abs(matrix[i][pivotCol]) > abs(matrix[maxRow][pivotCol])) { if (abs(matrix[i][pivotCol]) > abs(matrix[maxRow][pivotCol])) {
maxRow = i maxRow = i
} }
} }
// 检查主元是否为0 // 检查主元是否为0
if (abs(matrix[maxRow][pivotCol]) < 1e-10) { if (abs(matrix[maxRow][pivotCol]) < 1e-10) {
pivotCol++ pivotCol++
continue continue
} }
``` ```
@@ -107,15 +107,15 @@ continue
```kotlin ```kotlin
// 行交换 // 行交换
if (maxRow != pivotRow) { if (maxRow != pivotRow) {
val temp = matrix[pivotRow] val temp = matrix[pivotRow]
matrix[pivotRow] = matrix[maxRow] matrix[pivotRow] = matrix[maxRow]
matrix[maxRow] = temp matrix[maxRow] = temp
} }
// 归一化主元行 // 归一化主元行
val divisor = matrix[pivotRow][pivotCol] val divisor = matrix[pivotRow][pivotCol]
for (j in pivotCol until cols) { for (j in pivotCol until cols) {
matrix[pivotRow][j] /= divisor matrix[pivotRow][j] /= divisor
} }
``` ```
@@ -127,12 +127,12 @@ matrix[pivotRow][j] /= divisor
```kotlin ```kotlin
// 消元操作 // 消元操作
for (i in 0 until rows) { for (i in 0 until rows) {
if (i != pivotRow) { if (i != pivotRow) {
val factor = matrix[i][pivotCol] val factor = matrix[i][pivotCol]
for (j in pivotCol until cols) { for (j in pivotCol until cols) {
matrix[i][j] -= factor * matrix[pivotRow][j] matrix[i][j] -= factor * matrix[pivotRow][j]
} }
} }
} }
``` ```
+9 -4
View File
@@ -12,7 +12,7 @@ description: Kotlin 输出 HelloWorld
package top.blackcyan.kt package top.blackcyan.kt
fun main() { fun main() {
println("Hello, world!") println("Hello, world!")
} }
``` ```
@@ -23,8 +23,9 @@ println("Hello, world!")
package top.blackcyan.kt package top.blackcyan.kt
val message: ListOf<String> = ["Hello ", "world!"] val message: ListOf<String> = ["Hello ", "world!"]
message.forEach { message.forEach {
print(it) print(it)
} }
println() println()
@@ -36,9 +37,13 @@ println()
package top.blackcyan.kt package top.blackcyan.kt
fun greeting() = "Hello" fun greeting() = "Hello"
fun String.printOut() { println("${greeting()} $this!") }
fun String.printOut() {
println("${greeting()} $this!")
}
fun main() { fun main() {
"world".printOut() "world".printOut()
} }
``` ```
+117 -121
View File
@@ -34,68 +34,68 @@ data class Edge(val from: Int, val to: Int, val weight: Int)
// 并查集:用于判断环、合并集合 // 并查集:用于判断环、合并集合
class UnionFind(size: Int) { class UnionFind(size: Int) {
private val parent = IntArray(size) { it } private val parent = IntArray(size) { it }
// 查找根节点,并路径压缩 // 查找根节点,并路径压缩
fun find(x: Int): Int { fun find(x: Int): Int {
if (parent[x] != x) { if (parent[x] != x) {
parent[x] = find(parent[x]) parent[x] = find(parent[x])
} }
return parent[x] return parent[x]
} }
// 合并两个集合,若已经连通返回 false // 合并两个集合,若已经连通返回 false
fun union(x: Int, y: Int): Boolean { fun union(x: Int, y: Int): Boolean {
val rootX = find(x) val rootX = find(x)
val rootY = find(y) val rootY = find(y)
if (rootX == rootY) return false if (rootX == rootY) return false
parent[rootY] = rootX parent[rootY] = rootX
return true return true
} }
} }
// Kruskal 算法:从邻接矩阵生成边集合并构建最小生成树 // Kruskal 算法:从邻接矩阵生成边集合并构建最小生成树
fun kruskalFromAdjMatrix(adjMatrix: Array<IntArray>): List<Edge> { fun kruskalFromAdjMatrix(adjMatrix: Array<IntArray>): List<Edge> {
val nodeCount = adjMatrix.size val nodeCount = adjMatrix.size
val edges = extractEdgesFromMatrix(adjMatrix) val edges = extractEdgesFromMatrix(adjMatrix)
if (edges.isEmpty()) { if (edges.isEmpty()) {
throw IllegalArgumentException("图中没有有效的边") throw IllegalArgumentException("图中没有有效的边")
} }
return kruskal(nodeCount, edges) return kruskal(nodeCount, edges)
} }
// 辅助函数:从邻接矩阵中提取边(避免重复) // 辅助函数:从邻接矩阵中提取边(避免重复)
fun extractEdgesFromMatrix(matrix: Array<IntArray>): List<Edge> { fun extractEdgesFromMatrix(matrix: Array<IntArray>): List<Edge> {
val edges = mutableListOf<Edge>() val edges = mutableListOf<Edge>()
val n = matrix.size val n = matrix.size
for (i in 0 ..< n) { for (i in 0 ..< n) {
for (j in i + 1 ..< n) { for (j in i + 1 ..< n) {
val w = matrix[i][j] val w = matrix[i][j]
if (w != 0 && w != Int.MAX_VALUE) { if (w != 0 && w != Int.MAX_VALUE) {
edges.add(Edge(i, j, w)) edges.add(Edge(i, j, w))
} }
} }
} }
return edges return edges
} }
// Kruskal 主体:边排序 + 并查集连接 // Kruskal 主体:边排序 + 并查集连接
fun kruskal(nodeCount: Int, edges: List<Edge>): List<Edge> { fun kruskal(nodeCount: Int, edges: List<Edge>): List<Edge> {
val mst = mutableListOf<Edge>() val mst = mutableListOf<Edge>()
val uf = UnionFind(nodeCount) val uf = UnionFind(nodeCount)
for (edge in edges.sortedBy { it.weight }) { for (edge in edges.sortedBy { it.weight }) {
if (uf.union(edge.from, edge.to)) { if (uf.union(edge.from, edge.to)) {
mst.add(edge) mst.add(edge)
if (mst.size == nodeCount - 1) break if (mst.size == nodeCount - 1) break
} }
} }
return mst return mst
} }
``` ```
@@ -104,35 +104,34 @@ return mst
```kotlin ```kotlin
fun main() { fun main() {
val INF = Int.MAX_VALUE val INF = Int.MAX_VALUE
val adjMatrix = arrayOf( val adjMatrix = arrayOf(
intArrayOf(0, 7, INF, 5, INF, INF, INF), // A intArrayOf(0, 7, INF, 5, INF, INF, INF), // A
intArrayOf(7, 0, 8, 9, 7, INF, INF), // B intArrayOf(7, 0, 8, 9, 7, INF, INF), // B
intArrayOf(INF, 8, 0, INF, 5, INF, INF), // C intArrayOf(INF, 8, 0, INF, 5, INF, INF), // C
intArrayOf(5, 9, INF, 0, 15, 6, INF), // D intArrayOf(5, 9, INF, 0, 15, 6, INF), // D
intArrayOf(INF, 7, 5, 15, 0, 8, 9), // E intArrayOf(INF, 7, 5, 15, 0, 8, 9), // E
intArrayOf(INF, INF, INF, 6, 8, 0, 11), // F intArrayOf(INF, INF, INF, 6, 8, 0, 11), // F
intArrayOf(INF, INF, INF, INF, 9, 11, 0) // G intArrayOf(INF, INF, INF, INF, 9, 11, 0) // G
) )
val mst = kruskalFromAdjMatrix(adjMatrix) val mst = kruskalFromAdjMatrix(adjMatrix)
val cityNames = listOf("A", "B", "C", "D", "E", "F", "G") val cityNames = listOf("A", "B", "C", "D", "E", "F", "G")
println("最小花费的高铁修建方案如下:") println("最小花费的高铁修建方案如下:")
var totalCost = 0 var totalCost = 0
for (edge in mst) { for (edge in mst) {
println("${cityNames[edge.from]} -- ${cityNames[edge.to]} : 费用 ${edge.weight}") println("${cityNames[edge.from]} -- ${cityNames[edge.to]} : 费用 ${edge.weight}")
totalCost += edge.weight totalCost += edge.weight
} }
println("总花费:$totalCost") println("总花费:$totalCost")
} }
``` ```
输出结果: 输出结果:
```kotlin ```
"""
最小花费的高铁修建方案如下: 最小花费的高铁修建方案如下:
A -- D : 费用 5 A -- D : 费用 5
C -- E : 费用 5 C -- E : 费用 5
@@ -141,7 +140,6 @@ A -- B : 费用 7
B -- E : 费用 7 B -- E : 费用 7
E -- G : 费用 9 E -- G : 费用 9
总花费:39 总花费:39
"""
``` ```
@@ -159,48 +157,48 @@ Prim 算法同样基于贪心策略,但与 Kruskal 算法不同的是,它从
```kotlin ```kotlin
fun prim(adjMatrix: Array<IntArray>): List<Triple<Int, Int, Int>> { fun prim(adjMatrix: Array<IntArray>): List<Triple<Int, Int, Int>> {
val n = adjMatrix.size val n = adjMatrix.size
val visited = BooleanArray(n) { false } // 记录已加入 MST 的点 val visited = BooleanArray(n) { false } // 记录已加入 MST 的点
val minDist = IntArray(n) { Int.MAX_VALUE } // 每个点到 MST 的最小距离 val minDist = IntArray(n) { Int.MAX_VALUE } // 每个点到 MST 的最小距离
val parent = IntArray(n) { -1 } // 每个点在 MST 中的父节点 val parent = IntArray(n) { -1 } // 每个点在 MST 中的父节点
minDist[0] = 0 minDist[0] = 0
for (i in 0 ..< n) { for (i in 0 ..< n) {
// 选出未加入 MST 中、距离最小的点 // 选出未加入 MST 中、距离最小的点
var u = -1 var u = -1
var min = Int.MAX_VALUE var min = Int.MAX_VALUE
for (j in 0 ..< n) { for (j in 0 ..< n) {
if (!visited[j] && minDist[j] < min) { if (!visited[j] && minDist[j] < min) {
min = minDist[j] min = minDist[j]
u = j u = j
} }
} }
if (u == -1) break // 图不连通 if (u == -1) break // 图不连通
visited[u] = true visited[u] = true
// 用 u 点更新其他相邻点的最小距离 // 用 u 点更新其他相邻点的最小距离
for (v in 0 ..< n) { for (v in 0 ..< n) {
val weight = adjMatrix[u][v] val weight = adjMatrix[u][v]
if (!visited[v] && weight != 0 && weight < minDist[v]) { if (!visited[v] && weight != 0 && weight < minDist[v]) {
minDist[v] = weight minDist[v] = weight
parent[v] = u parent[v] = u
} }
} }
} }
// 构建结果 // 构建结果
val result = mutableListOf<Triple<Int, Int, Int>>() val result = mutableListOf<Triple<Int, Int, Int>>()
for (v in 1 ..< n) { for (v in 1 ..< n) {
val u = parent[v] val u = parent[v]
if (u != -1) { if (u != -1) {
result.add(Triple(u, v, adjMatrix[u][v])) result.add(Triple(u, v, adjMatrix[u][v]))
} }
} }
return result return result
} }
``` ```
@@ -209,35 +207,34 @@ return result
```kotlin ```kotlin
fun main() { fun main() {
val INF = Int.MAX_VALUE val INF = Int.MAX_VALUE
val adjMatrix = arrayOf( val adjMatrix = arrayOf(
intArrayOf(0, 7, INF, 5, INF, INF, INF), intArrayOf(0, 7, INF, 5, INF, INF, INF),
intArrayOf(7, 0, 8, 9, 7, INF, INF), intArrayOf(7, 0, 8, 9, 7, INF, INF),
intArrayOf(INF, 8, 0, INF, 5, INF, INF), intArrayOf(INF, 8, 0, INF, 5, INF, INF),
intArrayOf(5, 9, INF, 0, 15, 6, INF), intArrayOf(5, 9, INF, 0, 15, 6, INF),
intArrayOf(INF, 7, 5, 15, 0, 8, 9), intArrayOf(INF, 7, 5, 15, 0, 8, 9),
intArrayOf(INF, INF, INF, 6, 8, 0, 11), intArrayOf(INF, INF, INF, 6, 8, 0, 11),
intArrayOf(INF, INF, INF, INF, 9, 11, 0) intArrayOf(INF, INF, INF, INF, 9, 11, 0)
) )
val cityNames = listOf("A", "B", "C", "D", "E", "F", "G") val cityNames = listOf("A", "B", "C", "D", "E", "F", "G")
val mst = prim(adjMatrix) val mst = prim(adjMatrix)
println("最小花费的高铁修建方案如下:") println("最小花费的高铁修建方案如下:")
var totalCost = 0 var totalCost = 0
for ((u, v, w) in mst) { for ((u, v, w) in mst) {
println("${cityNames[u]} -- ${cityNames[v]} : 费用 $w") println("${cityNames[u]} -- ${cityNames[v]} : 费用 $w")
totalCost += w totalCost += w
} }
println("总花费:$totalCost") println("总花费:$totalCost")
} }
``` ```
输出结果: 输出结果:
```kotlin ```
"""
最小花费的高铁修建方案如下: 最小花费的高铁修建方案如下:
A -- B : 费用 7 A -- B : 费用 7
E -- C : 费用 5 E -- C : 费用 5
@@ -246,7 +243,6 @@ B -- E : 费用 7
D -- F : 费用 6 D -- F : 费用 6
E -- G : 费用 9 E -- G : 费用 9
总花费:39 总花费:39
"""
``` ```
+1 -1
View File
@@ -10,6 +10,6 @@ description: 总结一下三月份
我还认识了一些新的朋友,第一次在别人的群里有点存在感(感动) 我还认识了一些新的朋友,第一次在别人的群里有点存在感(感动)
我打算整一个新的兽设,然后约一个毛脸kig... 争取在生日前做完这一切吧。 我打算整一个新的兽设,然后约一个毛脸 kig... 争取在生日前做完这一切吧。
已经跟亲友确定好漫展时要跳的舞了,不知道我能不能学会(笑) 已经跟亲友确定好漫展时要跳的舞了,不知道我能不能学会(笑)
+150 -150
View File
@@ -15,16 +15,16 @@ from Maix import MIC_ARRAY as mic
import lcd import lcd
lcd.init() lcd.init()
mic.init() #默认配置 mic.init() # 默认配置
#mic.init(i2s_d0=23, i2s_d1=22, i2s_d2=21, i2s_d3=20, i2s_ws=19, i2s_sclk=18, sk9822_dat=24, sk9822_clk=25)#可自定义配置 IO # mic.init(i2s_d0=23, i2s_d1=22, i2s_d2=21, i2s_d3=20, i2s_ws=19, i2s_sclk=18, sk9822_dat=24, sk9822_clk=25) # 可自定义配置 IO
while True: while True:
imga = mic.get_map() # 获取声音源分布图像 imga = mic.get_map() # 获取声音源分布图像
b = mic.get_dir(imga) # 计算、获取声源方向 b = mic.get_dir(imga) # 计算、获取声源方向
a = mic.set_led(b,(0,0,255)) # 配置 RGB LED 颜色值 a = mic.set_led(b,(0,0,255)) # 配置 RGB LED 颜色值
imgb = imga.resize(160,160) imgb = imga.resize(160,160)
imgc = imgb.to_rainbow(1) # 将图像转换为彩虹图像 imgc = imgb.to_rainbow(1) # 将图像转换为彩虹图像
a = lcd.display(imgc) a = lcd.display(imgc)
mic.deinit() mic.deinit()
``` ```
@@ -50,30 +50,30 @@ mic.deinit()
import math import math
def get_sound_angle(energy_data): def get_sound_angle(energy_data):
if not energy_data or sum(energy_data) == 0: if not energy_data or sum(energy_data) == 0:
return None # 返回None表示无效数据 return None # 返回None表示无效数据
# 矢量求和法 # 矢量求和法
x_sum = 0.0 x_sum = 0.0
y_sum = 0.0 y_sum = 0.0
for i in range(12): for i in range(12):
angle_rad = math.radians(i * 30) angle_rad = math.radians(i * 30)
# 对能量值进行平方增强主声源权重 # 对能量值进行平方增强主声源权重
weighted_energy = energy_data[i] ** 2 weighted_energy = energy_data[i] ** 2
x_sum += weighted_energy * math.cos(angle_rad) x_sum += weighted_energy * math.cos(angle_rad)
y_sum += weighted_energy * math.sin(angle_rad) y_sum += weighted_energy * math.sin(angle_rad)
# 计算角度 # 计算角度
angle = math.degrees(math.atan2(y_sum, x_sum)) angle = math.degrees(math.atan2(y_sum, x_sum))
# 转换为-180~180范围 # 转换为 -180 ~ 180 范围
if angle > 180: if angle > 180:
angle -= 360 angle -= 360
elif angle < -180: elif angle < -180:
angle += 360 angle += 360
return int(angle) return int(angle)
``` ```
@@ -95,166 +95,166 @@ FILTER_WINDOW = 15 # 滤波窗口大小
SERVO_SMOOTH_FACTOR = 0.2 # 舵机运动平滑因子 SERVO_SMOOTH_FACTOR = 0.2 # 舵机运动平滑因子
def init(): def init():
global pwm, tim global pwm, tim
tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM) tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)
pwm = PWM(tim, freq=50, duty=7.5, pin=0) # 初始中间位置 pwm = PWM(tim, freq=50, duty=7.5, pin=0) # 初始中间位置
mic.init(i2s_d0=23, i2s_d1=22, i2s_d2=21, i2s_d3=20, mic.init(i2s_d0=23, i2s_d1=22, i2s_d2=21, i2s_d3=20,
i2s_ws=19, i2s_sclk=18, sk9822_clk=25, sk9822_dat=24) i2s_ws=19, i2s_sclk=18, sk9822_clk=25, sk9822_dat=24)
def get_sound_angle(energy_data): def get_sound_angle(energy_data):
if not energy_data or sum(energy_data) == 0: if not energy_data or sum(energy_data) == 0:
return None # 返回None表示无效数据 return None # 返回 None 表示无效数据
# 矢量求和法 # 矢量求和法
x_sum = 0.0 x_sum = 0.0
y_sum = 0.0 y_sum = 0.0
for i in range(12): for i in range(12):
angle_rad = math.radians(i * 30) angle_rad = math.radians(i * 30)
# 对能量值进行平方增强主声源权重 # 对能量值进行平方增强主声源权重
weighted_energy = energy_data[i] ** 2 weighted_energy = energy_data[i] ** 2
x_sum += weighted_energy * math.cos(angle_rad) x_sum += weighted_energy * math.cos(angle_rad)
y_sum += weighted_energy * math.sin(angle_rad) y_sum += weighted_energy * math.sin(angle_rad)
# 计算角度 # 计算角度
angle = math.degrees(math.atan2(y_sum, x_sum)) angle = math.degrees(math.atan2(y_sum, x_sum))
# 转换为-180~180范围 # 转换为 -180 ~ 180 范围
if angle > 180: if angle > 180:
angle -= 360 angle -= 360
elif angle < -180: elif angle < -180:
angle += 360 angle += 360
return int(angle) return int(angle)
def apply_filters(raw_angle): def apply_filters(raw_angle):
global angle_buffer global angle_buffer
# 1. 无效数据跳过 # 无效数据跳过
if raw_angle is None: if raw_angle is None:
return None return None
# 2. 更新数据缓冲区 # 更新数据缓冲区
angle_buffer.append(raw_angle) angle_buffer.append(raw_angle)
if len(angle_buffer) > FILTER_WINDOW: if len(angle_buffer) > FILTER_WINDOW:
angle_buffer.pop(0) angle_buffer.pop(0)
# 3. 中值滤波 # 中值滤波
sorted_angles = sorted(angle_buffer) sorted_angles = sorted(angle_buffer)
median_angle = sorted_angles[len(sorted_angles) // 2] median_angle = sorted_angles[len(sorted_angles) // 2]
# 4. 移动平均滤波 # 移动平均滤波
avg_angle = sum(angle_buffer) / len(angle_buffer) avg_angle = sum(angle_buffer) / len(angle_buffer)
# 5. 加权组合滤波结果 # 加权组合滤波结果
filtered_angle = 0.6 * median_angle + 0.4 * avg_angle filtered_angle = 0.6 * median_angle + 0.4 * avg_angle
# 6. 角度连续性处理 # 角度连续性处理
if filtered_angle > 180: if filtered_angle > 180:
filtered_angle -= 360 filtered_angle -= 360
elif filtered_angle < -180: elif filtered_angle < -180:
filtered_angle += 360 filtered_angle += 360
return int(filtered_angle) return int(filtered_angle)
def convert_angle(angle): def convert_angle(angle):
"""将声源角度映射到舵机控制信号 """将声源角度映射到舵机控制信号
参数: angle - 声源角度(-180~180度) 参数: angle - 声源角度(-180~180度)
返回: (有效角度, duty_val) 返回: (有效角度, duty_val)
""" """
# 将角度转换为0~360范围用于计算 # 将角度转换为 0 ~ 360 范围用于计算
angle_360 = angle % 360 angle_360 = angle % 360
if angle_360 < 0: if angle_360 < 0:
angle_360 += 360 angle_360 += 360
# 检查角度是否在有效范围内 (270°~90° 的半圆) # 检查角度是否在有效范围内
if 90 < angle_360 < 270: if 90 < angle_360 < 270:
return False, None # 无效角度 return False, None # 无效角度
# 映射角度到舵机控制信号: # 映射角度到舵机控制信号:
# - 90° -> duty 2.5 (右边) # - 90° -> duty 2.5 (右边)
# - 0° -> duty 7.5 (正前方) # - 0° -> duty 7.5 (正前方)
# - -90°/270° -> duty 12.5 (左边) # - -90°/270° -> duty 12.5 (左边)
# 线性映射到duty值 # 线性映射到duty值
# 角度范围: -90°到 90°映射到 duty 12.5 到 2.5 # 角度范围: -90° 到 90° 映射到 duty 12.5 到 2.5
duty_val = 7.5 - (angle / 18.0) duty_val = 7.5 - (angle / 18.0)
# 确保duty值在有效范围内 # 确保 duty 值在有效范围内
duty_val = max(2.5, min(12.5, duty_val)) duty_val = max(2.5, min(12.5, duty_val))
return True, duty_val return True, duty_val
def main(): def main():
global angle_buffer global angle_buffer
last_valid_duty = 7.5 # 最后有效的duty值(初始为中间位置) last_valid_duty = 7.5 # 最后有效的 duty 值
try: try:
# 初始化角度缓冲区 # 初始化角度缓冲区
print("初始化角度缓冲区...") print("初始化角度缓冲区...")
for i in range(FILTER_WINDOW): for i in range(FILTER_WINDOW):
imga = mic.get_map() imga = mic.get_map()
energy_data = mic.get_dir(imga) energy_data = mic.get_dir(imga)
raw_angle = get_sound_angle(energy_data) raw_angle = get_sound_angle(energy_data)
angle_buffer.append(raw_angle if raw_angle is not None else 0) angle_buffer.append(raw_angle if raw_angle is not None else 0)
print("填充缓冲区 %d/%d" % (i+1, FILTER_WINDOW)) print("填充缓冲区 %d/%d" % (i+1, FILTER_WINDOW))
time.sleep_ms(50) time.sleep_ms(50)
print("开始主循环...") print("开始主循环...")
while True: while True:
start_time = time.ticks_ms() start_time = time.ticks_ms()
# 获取原始数据 # 获取原始数据
imga = mic.get_map() imga = mic.get_map()
energy_data = mic.get_dir(imga) energy_data = mic.get_dir(imga)
mic.set_led(energy_data, (0, 0, 255)) mic.set_led(energy_data, (0, 0, 255))
# 计算原始角度 # 计算原始角度
raw_angle = get_sound_angle(energy_data) raw_angle = get_sound_angle(energy_data)
# 应用多级滤波 # 应用多级滤波
filtered_angle = apply_filters(raw_angle) filtered_angle = apply_filters(raw_angle)
# 如果本次数据无效,使用上次滤波结果 # 如果本次数据无效,使用上次滤波结果
if filtered_angle is None: if filtered_angle is None:
filtered_angle = angle_buffer[-1] if angle_buffer else 0 filtered_angle = angle_buffer[-1] if angle_buffer else 0
raw_str = str(raw_angle) if raw_angle is not None else "--" raw_str = str(raw_angle) if raw_angle is not None else "--"
info = "原始角度: %s° -> 滤波角度: %d°" % (raw_str, filtered_angle) info = "原始角度: %s° -> 滤波角度: %d°" % (raw_str, filtered_angle)
info += "\n能量数据: " + str(energy_data) info += "\n能量数据: " + str(energy_data)
print(info) print(info)
print(&#39;-&#39; * 30) print("-" * 30)
# 转换角度到舵机控制信号 # 转换角度到舵机控制信号
is_valid, duty_val = convert_angle(filtered_angle) is_valid, duty_val = convert_angle(filtered_angle)
if is_valid: if is_valid:
# 有效角度,使用平滑处理 # 有效角度,使用平滑处理
target_duty = duty_val target_duty = duty_val
# 平滑处理:混合上次的duty值和本次的目标值 # 平滑处理:混合上次的 duty 值和本次的目标值
smoothed_duty = last_valid_duty * (1 - SERVO_SMOOTH_FACTOR) + target_duty * SERVO_SMOOTH_FACTOR smoothed_duty = last_valid_duty * (1 - SERVO_SMOOTH_FACTOR) + target_duty * SERVO_SMOOTH_FACTOR
last_valid_duty = smoothed_duty last_valid_duty = smoothed_duty
duty_val = smoothed_duty duty_val = smoothed_duty
print("有效角度,duty_val:", duty_val) print("有效角度,duty_val:", duty_val)
else: else:
# 无效角度范围,保持上次的有效duty值 # 无效角度范围,保持上次的有效 duty 值
duty_val = last_valid_duty duty_val = last_valid_duty
print("角度 %d° 在无效范围,保持上次duty值: %.2f" % (filtered_angle, duty_val)) print("角度 %d° 在无效范围,保持上次duty值: %.2f" % (filtered_angle, duty_val))
pwm.duty(duty_val) pwm.duty(duty_val)
loop_time = time.ticks_diff(time.ticks_ms(), start_time) loop_time = time.ticks_diff(time.ticks_ms(), start_time)
delay_time = max(10, 100 - loop_time) delay_time = max(10, 100 - loop_time)
time.sleep_ms(delay_time) time.sleep_ms(delay_time)
except KeyboardInterrupt: except KeyboardInterrupt:
print(&#39;用户退出&#39;) print("用户退出")
finally: finally:
mic.deinit() mic.deinit()
pwm.duty(7.5) # 回到中间位置 pwm.duty(7.5) # 回到中间位置
print("资源已释放") print("资源已释放")
if __name__ == &#39;__main__&#39;: if __name__ == "__main__":
init() init()
main() main()
``` ```