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