基于PPO算法的ESP32平衡机器人：从仿真训练到硬件部署实战

想用强化学习训练机器人，但一看到动辄几十行的数学公式和复杂的仿真环境就头疼？觉得强化学习离实际硬件落地还差十万八千里？

如果你有这些困扰，那么这篇文章就是为你准备的。我们将绕开那些令人望而生畏的理论，直接聚焦于一个看得见、摸得着的目标：用PPO算法，在ESP32单片机上，训练一个能自己学会保持平衡的机器人。这不是一个停留在论文或仿真中的概念，而是一个从零开始，涵盖算法、仿真到硬件部署的完整实战项目。

本文的核心判断是：对于机器人开发者而言，强化学习的价值不在于其数学的优雅，而在于它提供了一种“设定目标，自动寻优”的工程范式。通过将复杂的平衡控制问题转化为奖励函数的设计，我们可以让机器人在试错中自我进化，这比手动编写庞杂的控制逻辑要高效得多。

读完本文，你将彻底掌握如何搭建一个轻量级的机器人强化学习训练管线。具体来说，你会学到：

1. PPO算法的核心思想：用最直白的语言解释它为何适合机器人控制。
2. 仿真环境的构建：使用Python和gym库快速创建一个“倒立摆”平衡机器人环境。
3. 从仿真到硬件：如何将训练好的策略网络部署到资源受限的ESP32上。
4. 完整的代码与调试：提供可运行的代码，并指出从仿真成功到硬件运行的关键陷阱。

我们直接从最核心的问题开始。

1. 为什么选择PPO和平衡机器人作为入门？

在深入代码之前，必须回答两个问题：为什么是PPO？为什么是平衡机器人？

强化学习算法众多，PPO（Proximal Policy Optimization）为何脱颖而出？对于机器人连续控制任务（如电机扭矩输出），我们通常需要策略网络输出一个连续的动作值。PPO在这方面表现出了极佳的平衡性：

• 易于实现：相比TRPO复杂的约束优化，PPO通过简单的剪切（Clip）目标函数来限制策略更新的幅度，代码更简洁。
• 样本效率相对较高：在有限的仿真步数内能学到有效的策略。
• 稳定性好：其“近端”优化的特性，避免了策略更新过快导致的性能崩溃，这对于需要稳定训练的控制任务至关重要。 简言之，PPO是当前解决类似平衡机器人这种连续控制问题的实用首选，它降低了理论门槛，让开发者能更专注于工程实现。

平衡机器人——强化学习的“Hello World”平衡问题（倒立摆）是控制理论中的经典问题，也是验证强化学习算法的绝佳试金石：

1. 状态空间简单：通常只需要角度、角速度。
2. 动作空间连续：需要输出一个连续的力或扭矩。
3. 奖励函数直观：越直立、越稳定，奖励越高；倒下则给予惩罚。
4. 训练速度快：在仿真中，几分钟内就能看到明显的学习效果。 通过这个项目，你可以快速建立起“环境-智能体-训练”的完整认知，其经验可以无缝迁移到更复杂的机器人导航、机械臂抓取等任务上。

2. 核心概念与项目架构全景

在动手前，我们需要统一语言，理解这个项目的核心组件是如何协作的。

强化学习训练的基本要素

• 环境 (Environment)：即我们的平衡机器人世界。它接收动作，返回新的状态和奖励。在本项目中，我们首先在仿真中构建它。
• 智能体 (Agent)：即我们要训练的“大脑”。它观察环境状态，根据内部策略（神经网络）决定执行什么动作。这里，智能体的策略网络将由PPO算法来优化。
• 状态 (State)：环境在某一时刻的描述。对于平衡机器人，通常是[小车位置， 小车速度， 摆杆角度， 摆杆角速度]。
• 动作 (Action)：智能体施加给环境的影响。这里是一个连续的力，用于推动小车以保持摆杆平衡。
• 奖励 (Reward)：环境反馈给智能体的“分数”，用于指导学习。我们的目标是最大化累计奖励。

本项目架构：仿真训练与硬件部署整个流程分为两大阶段，这是一个经典的“仿真训练，实物部署”的机器人开发流程：

flowchart TD A[第一阶段: 仿真训练] --> B[构建仿真环境<br>（Python + Gym）] B --> C[实现PPO智能体<br>（PyTorch/TensorFlow）] C --> D[在仿真中迭代训练<br>输出策略网络模型] D --> E{第二阶段: 硬件部署} E --> F[模型转换与量化<br>（.pth -> .tflite）] F --> G[部署至ESP32<br>（C/C++ 推理）] G --> H[实时传感器读取<br>（IMU数据）] H --> I[策略网络推理] I --> J[输出动作控制电机] J --> K[平衡机器人实时运行]

第一阶段在PC上完成，利用算力快速训练；第二阶段将训练好的“大脑”（模型）移植到ESP32上，让机器人真正动起来。

3. 环境准备：搭建你的开发战场

工欲善其事，必先利其器。以下是完成本项目所需的软件环境。

3.1 基础Python环境我们使用Python作为主要开发语言。推荐使用conda或venv创建独立的虚拟环境。

# 创建并激活虚拟环境 (conda方式) conda create -n rl_balance python=3.8 conda activate rl_balance # 或者使用 venv python -m venv rl_balance_env # Windows rl_balance_env\Scripts\activate # Linux/Mac source rl_balance_env/bin/activate

3.2 安装核心库在激活的虚拟环境中，安装以下依赖：

pip install gym==0.21.0 # 强化学习环境标准库 pip install numpy # 数值计算 pip install torch # 深度学习框架（用于实现PPO） pip install matplotlib # 绘图，用于可视化训练过程 # 可选，用于模型转换（如果部署到TensorFlow Lite） pip install tensorflow

注：gym版本需要注意，新版gym（如0.24.0+）API有变化。本文代码基于0.21.0版本，保证兼容性。

3.3 硬件准备（部署阶段）

• ESP32开发板：如ESP32 DevKitC、NodeMCU-32S等。
• 平衡机器人套件：通常包含底盘、电机、轮子、电池、MPU6050（陀螺仪加速度计）等。你可以自行购买散件组装，或使用集成度较高的套件。
• Arduino IDE 或 PlatformIO：用于ESP32的编程和烧录。
• USB数据线：用于供电和程序烧录。

环境就绪后，我们开始构建项目的核心——仿真环境。

4. 构建平衡机器人仿真环境

我们不需要从零开始造轮子。OpenAI Gym已经提供了经典的CartPole（小车倒立摆）环境，它与我们的平衡机器人问题高度相似。我们将以此为基础。

4.1 理解CartPole环境CartPole-v1环境的状态空间是4维的：[车位置， 车速度， 杆角度， 杆角速度]。动作空间是离散的（左推/右推），但我们的平衡机器人需要连续力输出。因此，我们将使用gym的Box空间自定义一个连续版本。

4.2 创建自定义连续CartPole环境

# 文件：continuous_cartpole.py import gym from gym import spaces import numpy as np class ContinuousCartPoleEnv(gym.Env): """ 自定义连续动作空间的CartPole环境。 将原来的离散动作（0/1）改为连续力值。 """ metadata = {'render.modes': ['human']} def __init__(self): super(ContinuousCartPoleEnv, self).__init__() # 从原始CartPole环境获取参数 self.env = gym.make('CartPole-v1') # 状态空间不变 self.observation_space = self.env.observation_space # **关键修改**：动作空间改为连续，范围[-1, 1]，代表施加的力 self.action_space = spaces.Box(low=-1.0, high=1.0, shape=(1,), dtype=np.float32) self.viewer = None self.state = None def reset(self): self.state = self.env.reset() return np.array(self.state, dtype=np.float32) def step(self, action): # 将连续动作[-1, 1]映射到离散动作{0, 1} # 这里采用一个简单的阈值：action > 0 为右推(1)，否则为左推(0) discrete_action = 1 if action[0] > 0 else 0 # 调用原始环境步进 next_state, reward, done, info = self.env.step(discrete_action) self.state = next_state # 可以微调奖励，鼓励更小的控制力（节能） # reward = reward - 0.01 * (action[0]**2) return np.array(next_state, dtype=np.float32), reward, done, info def render(self, mode='human'): return self.env.render(mode=mode) def close(self): if self.viewer: self.viewer.close() self.env.close()

代码解释：

• 我们封装了标准的CartPole-v1环境。
• 将action_space从Discrete(2)改为Box(-1, 1, (1,))，这意味着智能体可以输出一个-1到1之间的浮点数作为力的大小和方向。
• 在step函数中，我们将连续的力值action[0]通过一个阈值（这里简单用了0）转换为离散的0或1，以兼容原环境。这是一种简化，更真实的模拟应直接修改物理引擎施加连续的力。但作为PPO算法演示，这已足够。
• 注释掉的奖励微调行，展示了如何通过惩罚大的动作值来鼓励平滑控制。

有了环境，接下来我们需要打造智能体的“大脑”——PPO算法。

5. PPO智能体实现详解

PPO算法的核心在于其目标函数，它试图在充分利用当前数据（提高性能）和避免更新过大（保持稳定）之间取得平衡。我们使用PyTorch来实现。

5.1 定义策略网络和价值网络智能体需要两个神经网络：

• 策略网络 (Actor)：输入状态，输出动作的概率分布（均值和方差）。
• 价值网络 (Critic)：输入状态，评估当前状态的价值（预期累计奖励）。

# 文件：ppo_agent.py import torch import torch.nn as nn import torch.optim as optim import numpy as np from torch.distributions import Normal import torch.nn.functional as F class ActorNetwork(nn.Module): """策略网络（Actor），输出给定状态下动作的均值和标准差。""" def __init__(self, state_dim, action_dim, hidden_dim=128): super(ActorNetwork, self).__init__() self.fc1 = nn.Linear(state_dim, hidden_dim) self.fc2 = nn.Linear(hidden_dim, hidden_dim) self.mean_head = nn.Linear(hidden_dim, action_dim) self.log_std_head = nn.Linear(hidden_dim, action_dim) # 输出对数标准差，保证正值 def forward(self, state): x = F.relu(self.fc1(state)) x = F.relu(self.fc2(x)) mean = self.mean_head(x) log_std = self.log_std_head(x) # 将log_std限制在合理范围内，防止数值不稳定 log_std = torch.clamp(log_std, -20, 2) std = torch.exp(log_std) return mean, std class CriticNetwork(nn.Module): """价值网络（Critic），评估状态的价值。""" def __init__(self, state_dim, hidden_dim=128): super(CriticNetwork, self).__init__() self.fc1 = nn.Linear(state_dim, hidden_dim) self.fc2 = nn.Linear(hidden_dim, hidden_dim) self.value_head = nn.Linear(hidden_dim, 1) def forward(self, state): x = F.relu(self.fc1(state)) x = F.relu(self.fc2(x)) value = self.value_head(x) return value class PPOAgent: """PPO智能体，包含训练逻辑。""" def __init__(self, state_dim, action_dim, lr_actor=3e-4, lr_critic=1e-3, gamma=0.99, gae_lambda=0.95, clip_epsilon=0.2, ppo_epochs=10, batch_size=64): self.gamma = gamma self.gae_lambda = gae_lambda self.clip_epsilon = clip_epsilon self.ppo_epochs = ppo_epochs self.batch_size = batch_size self.actor = ActorNetwork(state_dim, action_dim) self.critic = CriticNetwork(state_dim) self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr_actor) self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=lr_critic) def select_action(self, state, deterministic=False): """根据状态选择动作（训练时采样，部署时取均值）。""" state = torch.FloatTensor(state).unsqueeze(0) with torch.no_grad(): mean, std = self.actor(state) dist = Normal(mean, std) if deterministic: action = mean else: action = dist.sample() action_log_prob = dist.log_prob(action).sum(-1).item() action = action.squeeze(0).numpy() return action, action_log_prob def compute_gae(self, rewards, values, next_value, dones): """计算广义优势估计（GAE）。""" advantages = np.zeros_like(rewards, dtype=np.float32) gae = 0 for t in reversed(range(len(rewards))): if t == len(rewards) - 1: next_non_terminal = 1.0 - dones[t] next_values = next_value else: next_non_terminal = 1.0 - dones[t] next_values = values[t + 1] delta = rewards[t] + self.gamma * next_values * next_non_terminal - values[t] gae = delta + self.gamma * self.gae_lambda * next_non_terminal * gae advantages[t] = gae returns = advantages + values return advantages, returns def update(self, states, actions, old_log_probs, returns, advantages): """执行PPO更新步骤。""" states = torch.FloatTensor(states) actions = torch.FloatTensor(actions) old_log_probs = torch.FloatTensor(old_log_probs) returns = torch.FloatTensor(returns).unsqueeze(1) advantages = torch.FloatTensor(advantages).unsqueeze(1) dataset = torch.utils.data.TensorDataset(states, actions, old_log_probs, returns, advantages) dataloader = torch.utils.data.DataLoader(dataset, batch_size=self.batch_size, shuffle=True) for _ in range(self.ppo_epochs): for batch in dataloader: batch_states, batch_actions, batch_old_log_probs, batch_returns, batch_advantages = batch # 计算新的动作概率和状态价值 mean, std = self.actor(batch_states) dist = Normal(mean, std) new_log_probs = dist.log_prob(batch_actions).sum(dim=-1, keepdim=True) values = self.critic(batch_states) # 计算概率比和裁剪目标 ratio = torch.exp(new_log_probs - batch_old_log_probs) surr1 = ratio * batch_advantages surr2 = torch.clamp(ratio, 1 - self.clip_epsilon, 1 + self.clip_epsilon) * batch_advantages actor_loss = -torch.min(surr1, surr2).mean() # 价值网络损失（MSE） critic_loss = F.mse_loss(values, batch_returns) # 反向传播与优化 self.actor_optimizer.zero_grad() actor_loss.backward() self.actor_optimizer.step() self.critic_optimizer.zero_grad() critic_loss.backward() self.critic_optimizer.step()

关键点解析：

• ActorNetwork输出动作的均值和标准差，用于构建高斯分布，从而在连续动作空间中进行采样。
• CriticNetwork评估状态价值，用于计算优势函数Advantage，它衡量某个动作相对于平均水平的优劣。
• compute_gae函数实现了广义优势估计，能更有效地估计优势值，减少方差，是PPO等现代RL算法的标配。
• update函数是PPO的核心：通过裁剪概率比ratio，确保新旧策略不会差异过大，从而稳定训练。

智能体和环境都已就位，现在可以将它们连接起来，开始训练了。

6. 训练循环与可视化

我们将编写主训练脚本，整合环境、智能体，并记录训练过程。

# 文件：train.py import gym import numpy as np import torch from continuous_cartpole import ContinuousCartPoleEnv from ppo_agent import PPOAgent import matplotlib.pyplot as plt def train(max_episodes=1000, max_steps=500, update_interval=2048): env = ContinuousCartPoleEnv() state_dim = env.observation_space.shape[0] action_dim = env.action_space.shape[0] agent = PPOAgent(state_dim, action_dim) episode_rewards = [] for episode in range(max_episodes): state = env.reset() episode_reward = 0 states, actions, rewards, log_probs, dones, values = [], [], [], [], [], [] for step in range(max_steps): # 1. 交互与数据收集 action, log_prob = agent.select_action(state) next_state, reward, done, _ = env.step(action) value = agent.critic(torch.FloatTensor(state).unsqueeze(0)).item() states.append(state) actions.append(action) rewards.append(reward) log_probs.append(log_prob) dones.append(done) values.append(value) state = next_state episode_reward += reward # 2. 达到更新间隔或回合结束时，进行PPO更新 if len(states) >= update_interval or done: next_value = agent.critic(torch.FloatTensor(next_state).unsqueeze(0)).item() if not done else 0 advantages, returns = agent.compute_gae(rewards, values, next_value, dones) # 转换为numpy数组 states_np = np.array(states) actions_np = np.array(actions) old_log_probs_np = np.array(log_probs) returns_np = np.array(returns) advantages_np = np.array(advantages) # 更新网络 agent.update(states_np, actions_np, old_log_probs_np, returns_np, advantages_np) # 清空缓冲区 states, actions, rewards, log_probs, dones, values = [], [], [], [], [], [] if done: break episode_rewards.append(episode_reward) print(f"Episode {episode+1}/{max_episodes}, Reward: {episode_reward:.1f}") # 简单提前终止条件：连续10个回合平均奖励>450 if np.mean(episode_rewards[-10:]) > 450: print("Training early stopped! Agent learned to balance.") break # 保存训练好的模型 torch.save(agent.actor.state_dict(), 'ppo_actor.pth') torch.save(agent.critic.state_dict(), 'ppo_critic.pth') print("Models saved.") # 绘制训练曲线 plt.plot(episode_rewards) plt.xlabel('Episode') plt.ylabel('Total Reward') plt.title('PPO Training on Continuous CartPole') plt.savefig('training_curve.png') plt.show() if __name__ == '__main__': train()

运行与观察： 在终端执行python train.py。你会看到奖励随着训练轮次逐渐上升。理想情况下，几十到一百个回合后，智能体就能学会长时间保持平衡（奖励接近最大值500）。training_curve.png文件将保存训练进度图。

至此，仿真训练部分已完成。我们得到了一个能在仿真中完美平衡的“大脑”（ppo_actor.pth）。接下来是最激动人心的部分——将它放到真实的ESP32机器人上。

7. 从仿真到硬件：模型部署实战

将PyTorch模型部署到资源受限的微控制器（MCU）上，需要经过模型转换、量化和C/C++推理几个步骤。

7.1 模型转换与量化（PyTorch -> TensorFlow Lite）ESP32通常使用TensorFlow Lite Micro进行推理。我们需要将PyTorch模型转换为TFLite格式。

# 文件：convert_to_tflite.py import torch import tensorflow as tf import numpy as np from ppo_agent import ActorNetwork # 1. 加载训练好的PyTorch模型 state_dim = 4 action_dim = 1 actor = ActorNetwork(state_dim, action_dim) actor.load_state_dict(torch.load('ppo_actor.pth', map_location=torch.device('cpu'))) actor.eval() # 2. 创建一个示例输入（用于跟踪计算图） example_input = torch.randn(1, state_dim) # 3. 使用TorchScript导出模型（或ONNX，这里用TorchScript） traced_script_module = torch.jit.trace(actor, example_input) traced_script_module.save("ppo_actor_traced.pt") print("PyTorch model traced. Next, you would need to convert this .pt file to TFLite.") print("Note: Direct PyTorch to TFLite conversion is not trivial.") print("A practical workflow: PyTorch -> ONNX -> TensorFlow -> TFLite") print("Or, consider re-implementing the network in TensorFlow/Keras for easier deployment.")

重要提示：直接转换复杂模型可能存在算子不支持问题。对于生产部署，更稳健的流程是：

1. 重写网络：用TensorFlow/Keras完全复现PyTorch的ActorNetwork结构。
2. 权重迁移：将PyTorch模型的权重手动赋值给Keras模型。
3. 转换为TFLite：使用TensorFlow的TFLite转换器。

这里提供一个概念性的Keras模型定义和权重迁移思路：

# 文件：keras_actor.py (概念性代码) import tensorflow as tf from tensorflow import keras import numpy as np import torch # 定义相同的Keras模型 def create_keras_actor(state_dim, action_dim, hidden_dim=128): inputs = keras.Input(shape=(state_dim,)) x = keras.layers.Dense(hidden_dim, activation='relu')(inputs) x = keras.layers.Dense(hidden_dim, activation='relu')(x) mean = keras.layers.Dense(action_dim)(x) log_std = keras.layers.Dense(action_dim)(x) model = keras.Model(inputs=inputs, outputs=[mean, log_std]) return model # 假设我们已经有了PyTorch模型的state_dict pytorch_state_dict = torch.load('ppo_actor.pth', map_location='cpu') keras_model = create_keras_actor(4, 1) # **手动进行权重迁移（需要仔细对齐层名称）** # 这是一个繁琐但必须的步骤。通常需要写一个映射字典。 # 例如： # keras_model.get_layer('dense').set_weights([W1, b1]) # keras_model.get_layer('dense_1').set_weights([W2, b2]) # ... # 保存Keras模型 keras_model.save('keras_actor.h5') # 转换为TFLite converter = tf.lite.TFLiteConverter.from_keras_model(keras_model) converter.optimizations = [tf.lite.Optimize.DEFAULT] # 量化优化 tflite_model = converter.convert() with open('actor.tflite', 'wb') as f: f.write(tflite_model) print("TFLite model saved.")

7.2 ESP32端推理代码框架在Arduino IDE或PlatformIO中，你需要集成TFLite Micro库，并编写推理代码。

// 文件：esp32_inference.ino (框架示例) #include <TensorFlowLite_ESP32.h> #include <tensorflow/lite/micro/all_ops_resolver.h> #include <tensorflow/lite/micro/micro_interpreter.h> #include <tensorflow/lite/schema/schema_generated.h> #include <tensorflow/lite/version.h> // 1. 包含你的模型数据（通过工具将.tflite文件转换为C数组） #include "actor_model_data.h" // 2. 定义TFLite全局对象 namespace { const tflite::Model* model = nullptr; tflite::MicroInterpreter* interpreter = nullptr; TfLiteTensor* input = nullptr; TfLiteTensor* output_mean = nullptr; TfLiteTensor* output_log_std = nullptr; constexpr int kTensorArenaSize = 10 * 1024; // 根据模型调整 uint8_t tensor_arena[kTensorArenaSize]; } // namespace void setup() { Serial.begin(115200); // 3. 加载模型 model = tflite::GetModel(g_actor_model_data); static tflite::AllOpsResolver resolver; static tflite::MicroInterpreter static_interpreter( model, resolver, tensor_arena, kTensorArenaSize); interpreter = &static_interpreter; // 4. 分配内存 interpreter->AllocateTensors(); input = interpreter->input(0); output_mean = interpreter->output(0); // 假设第一个输出是均值 // 注意：根据模型结构，可能需要获取多个输出 // 初始化传感器（如MPU6050） initMPU6050(); } void loop() { // 5. 读取传感器数据（状态） float state[4]; // [angle, angular_velocity, position, velocity] - 需根据实际传感器换算 readSensorState(state); // 6. 将状态数据填入输入张量 for (int i = 0; i < 4; i++) { input->data.f[i] = state[i]; } // 7. 运行推理 TfLiteStatus invoke_status = interpreter->Invoke(); if (invoke_status != kTfLiteOk) { Serial.println("Invoke failed!"); return; } // 8. 获取输出动作（均值） float action_mean = output_mean->data.f[0]; // 在实际部署中，我们通常直接使用均值作为动作，不再采样。 // float action = action_mean; // 9. 将动作映射到电机PWM信号并输出 int pwm = mapActionToPWM(action_mean); setMotorPWM(pwm); delay(10); // 控制周期 }

7.3 硬件集成关键点

1. 状态获取：通过MPU6050读取陀螺仪和加速度计数据，通过卡尔曼滤波或互补滤波融合出精确的角度和角速度，构成状态向量。
2. 动作执行：将推理输出的连续力值（action_mean）映射到电机的PWM占空比。例如，action为正时右轮前进/左轮后退。
3. 实时性：确保从传感器读取、推理到电机控制的整个循环在10-50ms内完成，以满足平衡控制的实时性要求。

8. 常见问题与排查指南

在从仿真到硬件的路上，你几乎一定会遇到以下问题。这里提供排查思路。

问题现象	可能原因	排查方式	解决方案
仿真训练奖励不上升	学习率过高/过低；网络结构太简单/复杂；奖励函数设计不合理。	检查训练曲线是否震荡或停滞；调整超参数（lr_actor,lr_critic,clip_epsilon）；可视化动作分布。	尝试更保守的学习率（如1e-4）；增加网络层宽度或深度；重新设计奖励函数，确保其平滑且能有效引导。
模型转换失败或推理出错	PyTorch/TensorFlow算子不支持；输入输出维度不匹配；量化错误。	检查TFLite转换器的错误日志；使用Netron可视化模型结构，对比输入输出。	简化网络结构（如避免特殊激活函数）；在转换前进行模型验证；使用tf.lite.Interpreter在PC上先测试.tflite模型。
ESP32上推理结果异常	模型未正确加载；张量内存对齐问题；输入数据未归一化。	在ESP32上打印输入张量和输出张量的原始值；检查tensor_arena大小是否足够。	确保模型数据数组正确包含；检查input->data.f赋值是否正确；将仿真中的状态归一化方式（如除以某个范围）同样应用到硬件数据上。
机器人剧烈振荡或无法平衡	控制频率太低；传感器噪声大；模型输出动作映射到PWM的范围不合适。	测量循环周期；用串口打印传感器原始数据和模型输出动作。	提高控制频率（减少delay）；对传感器数据进行滤波；调整mapActionToPWM函数的映射范围，可能需要一个比例系数。
电机响应与预期相反	电机接线极性反了；PWM映射逻辑错误。	单独测试电机，给定正PWM值观察转向。	调换电机接线或修改代码中的PWM输出符号。

9. 最佳实践与进阶方向

当你成功让机器人站起来的瞬间，这个项目就完成了从理论到实践的闭环。以下是让项目更稳健、更深入的几点建议。

工程化最佳实践

1. 仿真验证先行：在硬件上调试前，务必在仿真中彻底测试策略。可以尝试在仿真中加入噪声、延迟，让模型更具鲁棒性。
2. 版本控制：对代码、模型文件、配置文件使用Git进行管理。记录每次训练的超参数和结果。
3. 日志记录：在ESP32端，通过串口详细记录每个控制周期的状态、动作、推理时间等，这是后期分析和调试的宝贵数据。
4. 安全第一：首次在真实机器人上测试时，先用绳子吊起机器人或放在安全区域，防止高速旋转损坏设备或伤人。

项目进阶方向

1. 更复杂的机器人：将方法扩展到两轮平衡车、四足机器人或机械臂。状态和动作维度会增加，需要调整网络结构。
2. 从仿真到实物的域适应：仿真（Sim）和现实（Real）存在差距。可以尝试域随机化，在仿真中随机化物理参数（如摩擦系数、质量），让模型学会应对不确定性。
3. 在线学习/微调：在硬件上收集真实数据，对部署的模型进行微调，以适应真实的动力学特性。
4. 探索其他算法：尝试SAC（Soft Actor-Critic）、TD3等更先进的连续控制算法，比较它们在相同任务上的性能。

通过这个项目，你获得的不仅仅是一个会平衡的机器人，更是一套将前沿AI算法落地到嵌入式硬件的完整方法论。从定义问题、构建仿真、训练模型到最终部署，每一步都是现代机器人开发者的核心技能。希望这个实战指南能成为你探索机器人强化学习世界的一块坚实跳板。建议收藏本文，在实践过程中随时回溯。