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