PythonAI算法
AI 与嵌入式方向学习路线
提供 AI 与嵌入式融合的学习路径，涵盖 C 语言、单片机、Linux 基础及 Python AI 技能。重点讲解 TinyML 技术、模型压缩量化、TensorFlow Lite 部署及边缘计算框架。包含智能门锁、故障预测、垃圾分类等实战项目，并介绍端云协同与联邦学习等高级专题，适合希望进入嵌入式 AI 领域的开发者参考。
提供 AI 与嵌入式融合的学习路径，涵盖 C 语言、单片机、Linux 基础及 Python AI 技能。重点讲解 TinyML 技术、模型压缩量化、TensorFlow Lite 部署及边缘计算框架。包含智能门锁、故障预测、垃圾分类等实战项目，并介绍端云协同与联邦学习等高级专题，适合希望进入嵌入式 AI 领域的开发者参考。
C 语言进阶（1 个月）
// 必须掌握的核心知识
1. 指针和内存管理 - 指针数组、数组指针、函数指针 - 动态内存分配（malloc/free） - 内存对齐、内存泄漏检测
2. 数据结构（嵌入式常用） - 链表、队列、栈（纯 C 实现） - 循环缓冲区 - 状态机
3. 位操作 - 移位、掩码、位域 - 寄存器操作
4. 嵌入式编程规范 - volatile 关键字 - 中断安全的代码 - 代码优化技巧
// 示例：GPIO 寄存器操作
#define GPIO_BASE 0x40020000
#define SET_BIT(reg, bit) ((reg) |= (1 << (bit)))
#define CLEAR_BIT(reg, bit) ((reg) &= ~(1 << (bit)))
推荐资源：
单片机基础（1.5 个月）
学习路线：Arduino（入门）→ STM32（主流）→ ESP32（WiFi+BT）
Arduino 阶段（2 周）：
├─ 开发板：Arduino Uno
├─ 基础实验
│ ├─ GPIO：LED、按键、中断
│ ├─ 定时器：PWM、延时
│ ├─ 串口通信：UART
│ ├─ I2C/SPI：传感器通信
│ └─ ADC：模拟信号采集
└─ 小项目：温湿度采集系统
STM32 阶段（4 周）：
├─ 开发板：STM32F103/STM32F407
├─ 开发环境：STM32CubeMX + Keil/STM32CubeIDE
├─ 核心知识
│ ├─ HAL 库/寄存器操作
│ ├─ 时钟配置
│ ├─ 中断优先级
│ ├─ DMA 数据搬运
│ ├─ RTOS（FreeRTOS）
│ └─ 低功耗模式
└─ 项目：多传感器数据采集 + 串口上报
ESP32 阶段（2 周）：
├─ 开发板：ESP32-DevKitC
├─ 特色功能
│ ├─ WiFi/蓝牙通信
│ ├─ ESP-IDF 框架
│ └─ OTA 远程升级
└─ 项目：物联网数据采集节点
推荐资源：
Linux 嵌入式（1 个月）
# 学习路线
基础命令 → Shell 脚本 → 交叉编译 → 驱动开发入门
1. Linux 基础（1 周）
- 文件操作、权限管理
- vi/vim 编辑器
- gcc/make/gdb 工具链
2. Shell 脚本（1 周）
- 变量、循环、条件判断
- 文本处理（grep/sed/awk）
- 自动化脚本
3. 交叉编译（1 周）
- ARM 工具链安装
- 交叉编译程序
- 烧录到开发板
4. 驱动开发入门（1 周）
- 字符设备驱动
- GPIO 驱动
- 中断处理
开发板推荐：
推荐资源：
Python 编程（2 周）
# 嵌入式 AI 必备 Python 技能
1. 基础语法
- 数据类型、控制流
- 函数、类、模块
2. 科学计算库
import numpy as np
arr = np.array([1, 2, 3])
matrix = np.random.randn(3, 3)
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [4, 5, 6])
3. 数据处理
import pandas as pd
data = pd.read_csv('sensor_data.csv')
机器学习基础（1 个月）
# 必须理解的核心概念
1. 监督学习
- 线性回归：温度预测
- 逻辑回归：故障分类
- 决策树：规则推理
- SVM：小样本分类
2. 非监督学习
- K-Means：数据聚类
- 异常检测：故障诊断
3. 深度学习入门
- 神经网络原理
- 前向传播、反向传播
- 损失函数、优化器
# 示例：简单的温度预测模型
from sklearn.linear_model import LinearRegression
X = [[1], [2], [3], [4], [5]]
y = [20, 22, 24, 26, 28]
model = LinearRegression()
model.fit(X, y)
prediction = model.predict([[6]])
print(f"预测温度：{prediction[0]:.2f}°C")
推荐资源：
深度学习框架（1 个月）
# TensorFlow/Keras（嵌入式部署用 TFLite）
1. Keras 构建模型
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D(),
layers.Flatten(),
layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=5)
2. 模型量化（关键！）
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
with open('model.tflite', 'wb') as f:
f.write(tflite_model)
3. PyTorch（可选）
import torch
import torch.nn as nn
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 32, 3)
self.fc = nn.Linear(32*26*26, 10)
def forward(self, x):
x = torch.relu(self.conv1(x))
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
推荐资源：
模型压缩与量化（1 个月）
# 四大核心技术
1. 剪枝（Pruning）
import tensorflow_model_optimization as tfmot
prune_low_magnitude = tfmot.sparsity.keras.prune_low_magnitude
pruning_params = {
'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
initial_sparsity=0.0,
final_sparsity=0.5,
begin_step=0,
end_step=1000
)
}
model_for_pruning = prune_low_magnitude(model, **pruning_params)
2. 量化（Quantization）
# INT8 量化（32 位 → 8 位，速度提升 4 倍，模型缩小 4 倍）
converter = tf.lite.TFLiteConverter.from_keras_model(model)
def representative_dataset():
for _ in range(100):
yield [np.random.randn(1, 28, 28, 1).astype(np.float32)]
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_model = converter.convert()
3. 知识蒸馏（Knowledge Distillation）
class Distiller(keras.Model):
def __init__(self, student, teacher):
super().__init__()
self.teacher = teacher
self.student = student
def compile(self, optimizer, student_loss, distillation_loss, alpha=0.1):
super().compile(optimizer=optimizer)
self.student_loss = student_loss
self.distillation_loss = distillation_loss
self.alpha = alpha
def train_step(self, data):
x, y = data
teacher_predictions = self.teacher(x, training=False)
with tf.GradientTape() as tape:
student_predictions = self.student(x, training=True)
student_loss = self.student_loss(y, student_predictions)
distillation_loss = self.distillation_loss(
tf.nn.softmax(teacher_predictions),
tf.nn.softmax(student_predictions)
)
loss = self.alpha * student_loss + (1 - self.alpha) * distillation_loss
trainable_vars = self.student.trainable_variables
gradients = tape.gradient(loss, trainable_vars)
self.optimizer.apply_gradients(zip(gradients, trainable_vars))
return {"loss": loss}
4. MobileNet 架构
from tensorflow.keras.applications import MobileNetV2
base_model = MobileNetV2(
input_shape=(224, 224, 3),
alpha=0.35,
include_top=False,
weights='imagenet'
)
模型大小对比：
原始 ResNet50: 98MB
↓ 剪枝 50% 49MB
↓ INT8 量化 12MB
↓ 知识蒸馏到 MobileNetV2 3MB ✅ 适合嵌入式部署
推荐资源：
TensorFlow Lite（重点，1.5 个月）
# PC 端训练 → 嵌入式推理完整流程
## Part 1: 模型训练（PC 端）
import tensorflow as tf
from tensorflow import keras
model = keras.Sequential([
keras.layers.Conv2D(32, 3, activation='relu', input_shape=(96, 96, 3)),
keras.layers.MaxPooling2D(),
keras.layers.Conv2D(64, 3, activation='relu'),
keras.layers.MaxPooling2D(),
keras.layers.Flatten(),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10, validation_split=0.2)
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
import tensorflow_model_optimization as tfmot
q_aware_model = tfmot.quantization.keras.quantize_model(model)
q_aware_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
q_aware_model.fit(train_images, train_labels, epochs=3)
converter = tf.lite.TFLiteConverter.from_keras_model(q_aware_model)
tflite_model = converter.convert()
with open('model_quantized.tflite', 'wb') as f:
f.write(tflite_model)
## Part 2: 微控制器部署（STM32/ESP32）
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_error_reporter.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"
#include "model_data.h"
constexpr int kTensorArenaSize = 60 * 1024;
uint8_t tensor_arena[kTensorArenaSize];
tflite::MicroErrorReporter micro_error_reporter;
tflite::AllOpsResolver resolver;
const tflite::Model* model = tflite::GetModel(model_data);
tflite::MicroInterpreter interpreter(
model, resolver, tensor_arena, kTensorArenaSize, µ_error_reporter
);
interpreter.AllocateTensors();
TfLiteTensor* input = interpreter.input(0);
for (int i = 0; i < 96*96*3; i++) {
input->data.int8[i] = image_data[i];
}
TfLiteStatus invoke_status = interpreter.Invoke();
TfLiteTensor* output = interpreter.output(0);
int8_t max_score = -128;
int predicted_class = 0;
for (int i = 0; i < 10; i++) {
if (output->data.int8[i] > max_score) {
max_score = output->data.int8[i];
predicted_class = i;
}
}
printf("预测类别：%d, 置信度：%d\n", predicted_class, max_score);
实战项目：语音唤醒词识别
硬件：ESP32 + I2S 麦克风
模型：1D CNN（关键词检测）
流程：
1. 采集音频（16kHz 采样）
2. 提取 MFCC 特征（音频 → 频谱图）
3. TFLite 推理
4. 检测到"Hi AI"触发唤醒
推荐资源：
Edge Impulse（最简单，1 个月）
# 无代码/低代码边缘 AI 平台
学习路线：
1. 注册 Edge Impulse 账号
2. 创建项目 → 数据采集
3. 设计模型（拖拽式界面）
4. 训练 → 部署到硬件
支持硬件：
- Arduino Nano 33 BLE Sense
- ESP32
- 树莓派
- STM32
典型项目：
1. 手势识别（加速度计）
2. 关键词识别（麦克风）
3. 图像分类（摄像头）
优势：
✅ 自动生成嵌入式代码（Arduino/C++）
✅ 内置数据增强
✅ 自动优化模型
✅ 实时性能分析
部署示例：
#include <your_project_inferencing.h>
void setup() {
Serial.begin(115200);
}
void loop() {
float features[EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE];
get_sensor_data(features);
signal_t signal;
numpy::signal_from_buffer(features, EI_CLASSIFIER_DSP_INPUT_FRAME_SIZE, &signal);
ei_impulse_result_t result;
run_classifier(&signal, &result, false);
for (int i = 0; i < EI_CLASSIFIER_LABEL_COUNT; i++) {
Serial.printf("%s: %.2f\n", result.classification[i].label, result.classification[i].value );
}
}
推荐资源：
其他框架（了解）
1. NCNN（腾讯） - 专为移动端优化 - C++ 实现，速度极快
2. MNN（阿里） - 轻量级推理引擎 - 支持多种硬件加速
3. OpenVINO（Intel） - 专为 Intel 硬件优化
4. CMSIS-NN（ARM） - ARM Cortex-M 优化 - 汇编级加速
神经网络加速器（1 个月）
# AI 专用芯片/模块
1. Coral Edge TPU - Google 设计的 AI 加速器 - 4 TOPS 算力
2. Kendryte K210 - 0.23 TOPS 算力 - RISC-V 架构
3. BL702（博流） - RISC-V + NPU - 超低功耗
4. Jetson Nano（高端） - NVIDIA GPU - 适合复杂 AI 任务
FPGA 加速（选学）
用 Verilog/VHDL 实现神经网络加速
优势：可定制化硬件、极低延迟、并行计算
入门平台：Xilinx PYNQ-Z2、Intel DE10-Nano
硬件清单：
- STM32H7（主控，400MHz）
- OV2640 摄像头（QVGA 320x240）
- LCD 屏幕（显示）
- 舵机（开锁）
技术栈：
1. 人脸检测：MTCNN（轻量版）
2. 人脸识别：MobileFaceNet
3. 模型量化：INT8
4. 推理引擎：TFLite Micro
性能指标：
- 检测速度：200ms/帧
- 识别准确率：95%+
- 内存占用：<512KB
完整代码框架：
// main.c
#include "camera.h"
#include "lcd.h"
#include "face_detection.h"
#include "face_recognition.h"
void main() {
Camera_Init();
LCD_Init();
FaceDetection_Init();
FaceRecognition_Init();
while(1) {
uint8_t* image = Camera_Capture();
BoundingBox bbox;
if (FaceDetection_Detect(image, &bbox)) {
uint8_t face_region[112*112*3];
CropFace(image, &bbox, face_region);
int person_id = FaceRecognition_Identify(face_region);
if (IsAuthorized(person_id)) {
UnlockDoor();
LCD_ShowString("Welcome!");
} else {
LCD_ShowString("Access Denied");
}
}
Delay_ms(100);
}
}
// face_detection.c（TFLite 推理）
#include "model_face_detection.h"
int FaceDetection_Detect(uint8_t* image, BoundingBox* bbox) {
uint8_t input[128*128*3];
ResizeImage(image, 320, 240, input, 128, 128);
TfLiteTensor* input_tensor = interpreter->input(0);
memcpy(input_tensor->data.int8, input, 128*128*3);
interpreter->Invoke();
TfLiteTensor* output = interpreter->output(0);
if (output->data.f[0] > 0.9) {
bbox->x = output->data.f[1] * 320;
bbox->y = output->data.f[2] * 240;
bbox->w = output->data.f[3] * 320;
bbox->h = output->data.f[4] * 240;
return 1;
}
return 0;
}
应用场景：电机振动异常检测
硬件：
- ESP32（WiFi 上传数据）
- MPU6050（加速度计）
- OLED 显示屏
AI 模型：
# 1. 数据采集
# 采集正常运行时的振动数据（3 轴加速度）
# 采集故障时的数据（轴承损坏、不平衡等）
# 2. 特征工程
import numpy as np
from scipy import signal
def extract_features(accel_data):
features = []
features.append(np.mean(accel_data))
features.append(np.std(accel_data))
features.append(np.max(accel_data))
features.append(np.sqrt(np.mean(accel_data**2)))
fft = np.fft.fft(accel_data)
freq_magnitudes = np.abs(fft)[:len(fft)//2]
features.append(np.max(freq_magnitudes))
features.append(np.argmax(freq_magnitudes))
return np.array(features)
# 3. 构建模型（1D CNN + LSTM）
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
layers.Conv1D(32, 3, activation='relu', input_shape=(window_size, 3)),
layers.MaxPooling1D(2),
layers.Conv1D(64, 3, activation='relu'),
layers.GlobalMaxPooling1D(),
layers.Dense(64, activation='relu'),
layers.Dropout(0.5),
layers.Dense(3, activation='softmax')
])
# 4. 量化部署
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
ESP32 推理代码：
// ESP32 Arduino 代码
#include <Wire.h>
#include <MPU6050.h>
#include <WiFi.h>
#include "model.h"
MPU6050 mpu;
TfLiteTensor* input;
TfLiteTensor* output;
#define WINDOW_SIZE 100
float accel_buffer[WINDOW_SIZE][3];
int buffer_index = 0;
void setup() {
Wire.begin();
mpu.initialize();
WiFi.begin(ssid, password);
initTFLite();
}
void loop() {
int16_t ax, ay, az;
mpu.getAcceleration(&ax, &ay, &az);
accel_buffer[buffer_index][0] = ax / 16384.0;
accel_buffer[buffer_index][1] = ay / 16384.0;
accel_buffer[buffer_index][2] = az / 16384.0;
buffer_index++;
if (buffer_index >= WINDOW_SIZE) {
for (int i = 0; i < WINDOW_SIZE; i++) {
for (int j = 0; j < 3; j++) {
input->data.f[i*3 + j] = accel_buffer[i][j];
}
}
interpreter->Invoke();
float normal_prob = output->data.f[0];
float warning_prob = output->data.f[1];
float fault_prob = output->data.f[2];
if (fault_prob > 0.8) {
Serial.println("检测到故障!");
sendAlertToCloud();
} else if (warning_prob > 0.6) {
Serial.println("预警：设备异常");
} else {
Serial.println("运行正常");
}
buffer_index = 0;
}
delay(10);
}
硬件：
- 树莓派 4B + Coral USB 加速器
- 树莓派摄像头
- 舵机（控制垃圾桶盖）
技术方案：
# 1. 模型训练（垃圾分类数据集）
import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
base_model = MobileNetV2(
input_shape=(224, 224, 3),
include_top=False,
weights='imagenet'
)
base_model.trainable = False
model = tf.keras.Sequential([
base_model,
tf.keras.layers.GlobalAveragePooling2D(),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(4, activation='softmax')
])
# 2. Edge TPU 转换
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_model = converter.convert()
!edgetpu_compiler model.tflite
# 3. 树莓派部署
from picamera import PiCamera
from pycoral.utils import edgetpu
from pycoral.adapters import common, classify
import RPi.GPIO as GPIO
camera = PiCamera()
interpreter = edgetpu.make_interpreter('model_edgetpu.tflite')
interpreter.allocate_tensors()
SERVO_PIN = 18
GPIO.setup(SERVO_PIN, GPIO.OUT)
pwm = GPIO.PWM(SERVO_PIN, 50)
CLASSES = ['可回收', '有害垃圾', '厨余垃圾', '其他垃圾']
while True:
camera.capture('temp.jpg')
image = Image.open('temp.jpg').resize((224, 224))
common.set_input(interpreter, image)
interpreter.invoke()
classes = classify.get_classes(interpreter, top_k=1)
category = CLASSES[classes[0].id]
confidence = classes[0].score
if confidence > 0.8:
print(f"识别为：{category}, 置信度：{confidence:.2%}")
open_bin(category)
time.sleep(2)
硬件：
- nRF52832（蓝牙低功耗芯片）
- MAX30102（心率血氧传感器）
- MPU6050（姿态传感器）
- 纽扣电池供电
AI 功能：
1. 心率异常检测（LSTM 时序模型）
2. 跌倒检测（加速度突变识别）
3. 睡眠质量分析（多传感器融合）
核心代码：
// nRF52 SDK 开发
#include "nrf_delay.h"
#include "max30102.h"
#include "mpu6050.h"
#include "tflite_micro.h"
#define HEART_RATE_WINDOW 60
float hr_buffer[HEART_RATE_WINDOW];
int hr_index = 0;
void main() {
MAX30102_Init();
MPU6050_Init();
BLE_Init();
TFLite_Init("heart_rate_model.tflite");
while(1) {
uint8_t hr = MAX30102_GetHeartRate();
hr_buffer[hr_index++] = hr;
int16_t ax, ay, az;
MPU6050_GetAccel(&ax, &ay, &az);
float accel_magnitude = sqrt(ax*ax + ay*ay + az*az);
if (accel_magnitude > FALL_THRESHOLD) {
SendFallAlert();
}
if (hr_index >= HEART_RATE_WINDOW) {
float anomaly_score = RunHeartRateModel(hr_buffer);
if (anomaly_score > 0.8) {
SendHeartRateAlert();
}
hr_index = 0;
}
BLE_SendData(hr, ax, ay, az);
nrf_delay_ms(1000);
}
}
float RunHeartRateModel(float* data) {
float normalized[HEART_RATE_WINDOW];
for (int i = 0; i < HEART_RATE_WINDOW; i++) {
normalized[i] = (data[i] - 60.0) / 40.0;
}
TfLiteTensor* input = interpreter->input(0);
memcpy(input->data.f, normalized, sizeof(normalized));
interpreter->Invoke();
TfLiteTensor* output = interpreter->output(0);
return output->data.f[0];
}
架构：设备端（轻量模型） + 云端（复杂模型）
场景：
- 初筛在设备，详细分析在云端
- 设备资源不足时上传云端
技术栈：
- MQTT 协议（设备 ↔ 云）
- 云平台服务
- 模型热更新（OTA）
# 隐私保护的分布式训练
import tensorflow_federated as tff
def create_keras_model():
return tf.keras.Sequential([
tf.keras.layers.Dense(10, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
def model_fn():
keras_model = create_keras_model()
return tff.learning.from_keras_model(
keras_model, input_spec=..., loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]
)
iterative_process = tff.learning.build_federated_averaging_process(model_fn)
state = iterative_process.initialize()
for round_num in range(10):
state, metrics = iterative_process.next(state, federated_train_data)
print(f'round {round_num}, metrics={metrics}')
# 自动设计适合嵌入式的网络结构
from keras_tuner import HyperModel, RandomSearch
class MyHyperModel(HyperModel):
def build(self, hp):
model = keras.Sequential()
for i in range(hp.Int('num_layers', 1, 5)):
model.add(layers.Conv2D(
filters=hp.Choice(f'filters_{i}', [16, 32, 64]),
kernel_size=3, activation='relu'
))
model.add(layers.MaxPooling2D())
model.add(layers.Flatten())
model.add(layers.Dense(10, activation='softmax'))
model.compile(
optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']
)
return model
tuner = RandomSearch(
MyHyperModel(), objective='val_accuracy', max_trials=50, executions_per_trial=2
)
tuner.search(train_data, train_labels, epochs=10, validation_split=0.2)
best_model = tuner.get_best_models(num_models=1)[0]
# Python 环境
conda create -n tinyml python=3.9
conda activate tinyml
pip install tensorflow==2.13
pip install tensorflow-model-optimization
pip install numpy pandas matplotlib scikit-learn
# 嵌入式开发
# STM32: STM32CubeIDE
# ESP32: Arduino IDE / ESP-IDF
# 树莓派：Raspberry Pi OS
# AI 工具
pip install edge-impulse-cli
pip install pycoral
pip install onnx onnxruntime
pip install netron
入门套件：
├─ Arduino Nano 33 BLE Sense（内置 9 轴 IMU、麦克风、温湿度）
├─ ESP32-CAM（摄像头、WiFi/BT）
└─ 各种传感器套装
进阶套件：
├─ STM32H7 开发板
├─ OV2640 摄像头
├─ Coral USB Accelerator
├─ 树莓派 4B 4GB
└─ 各种模块
专业套件：
├─ Jetson Nano 4GB
├─ RealSense 深度相机
├─ Lidar 传感器
└─ 高精度 IMU
1. 嵌入式 AI 工程师
2. 边缘计算工程师
3. AIoT 开发工程师
4. 计算机视觉工程师（嵌入式方向）
5. 自动驾驶感知工程师
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online