Johnny-Five 舵机机器人 Bug 实战:用两个 Servo 搭建可前进后退的仿生行走机器人

原创2026-09-21 14:51:261,462 阅读
文章标签:IoT机器人嵌入式

Johnny-Five 舵机机器人 Bug 实战:用两个 Servo 搭建可前进后退的仿生行走机器人

本文以 Johnny-Five 官方示例 docs/bug.md 及其配套源码 eg/bug.js 为骨架,系统拆解如何用两个标准舵机(Servo)构建一个名为 Bug 的仿生机器人:包括自定义 Bug 类的设计、步态(STEP_MAP)调度、连续前进/后退的控制逻辑,以及如何借助 Johnny-Five 的 REPL 注入能力在运行期实时操纵机器人。读完本文,你将掌握 Johnny-Five 中「面向对象封装舵机机器人」「步态状态机」「定时器驱动的连续运动」三套可复用的实战模式,并能直接运行示例验证效果。

示例概览与运行方式

docs/bug.md 是一个标准的 Johnny-Five 官方示例文档,演示了一个极简的两舵机仿生机器人。运行命令为:

node eg/bug.js

(docs/bug.md 中给出的命令,对应仓库根目录下 eg/bug.js 文件。)

在运行前,请确保:

  1. 已安装 Johnny-Five:npm install johnny-five;
  2. Arduino 等开发板已烧录 StandardFirmata 固件并连接 USB;
  3. 两个标准舵机分别接在数字引脚 9(前腿 front)和 10(后腿 rear)。

从源码结构看,示例本身是一个完整的、可直接 node 执行的脚本,其 require 路径指向仓库内源码 require("../lib/johnny-five.js"),这与文档中通过 npm 包名 require("johnny-five") 的方式等价。

Bug 机器人整体设计

Bug 是一个用构造函数 + 原型方法组织起来的 JavaScript 类,核心职责是把「四条腿」抽象为若干舵机部件,并把「前进、后退」翻译成一组组舵机角度指令。其整体结构如下:

function Bug(servos) {
  var part, k;

  this.isMoving = false;

  // Initialize list of body parts
  this.parts = ["front", "left", "right", "rear"];

  // Servo positions
  this.history = [];

  // Interval id table
  this.intervals = {
    fwd: null,
    rev: null
  };

  k = -1;
  // Initialize Servo properties from "servos" argument
  while (++k < this.parts.length) {
    part = this.parts[k];

    this[part] = servos[part] || null;
  }

  // Unwind and wait ~10ms, center servos
  setTimeout(function() {
    this.idle();
  }.bind(this), 10);
}

构造函数承担四类初始化职责:

成员 类型 作用
parts Array 声明机器人身体部位清单:front / left / right / rear,用于后续循环挂载舵机实例
history Array 步态历史栈,记录每次迈步的方向、步序与前后舵角度,供下一步计算参照
intervals Object 定时器句柄表,分别保存 fwd、rev 两个方向的 setInterval 句柄
isMoving Boolean 运动状态标志,供 idle() 判断是否需要先停掉正在运行的定时器

部件注入与缺省容错

构造函数通过 while 循环遍历 parts,把外部传入的 servos 对象中同名字段挂到实例属性上:

this[part] = servos[part] || null;

这意味着:没有传入的部件保持 null,传入的部件则成为可用的 five.Servo 实例。示例中只挂载了 front 和 rear 两个舵机:

bug = new Bug({
  front: new five.Servo(9),
  rear: new five.Servo(10)
    //,
    //left: new five.Servo({ pin: 5, range: [ 70, 115 ] }),
    //right: new five.Servo({ pin: 6, range: [ 70, 115 ] })
});

注释中保留了四足扩展的写法:左右腿使用对象式参数 { pin, range }。关于 range 的含义,可从 lib/servo.js 源码确认:Servo 构造器默认 degreeRange = [0, 180]、range = options.range || this.degreeRange,也就是说 range 限制的是舵机允许转动的角度区间,而不是 PWM 脉宽;PWM 宽度由 pwmRange(默认 [600, 2400])控制。给左右腿设置 range: [70, 115] 这类收窄区间,可以让机械结构上受物理限制的关节不至于越界。

启动自校准

构造函数的最后,用一个 10ms 的 setTimeout 调用 this.idle():

setTimeout(function() {
  this.idle();
}.bind(this), 10);

bind(this) 保证了回调内 this 仍指向 Bug 实例。10ms 的延时是为了让舵机上电后先"喘口气"(代码注释称之为 Unwind),再统一回中,避免上电瞬间产生抖动或冲突。

步态核心:STEP_MAP 与 step()

机器人运动的灵魂是静态步态表 Bug.STEP_MAP。它把「前进 fwd」和「后退 rev」各拆成两步,每步用 [前腿角度偏移, 后腿角度偏移] 表示(相对 90° 中位的增量):

Bug.STEP_MAP = {
  // steps
  fwd: [
    [10, -30],
    [-15, 30]
  ],
  rev: [
    [-15, 30],
    [15, -30]
  ]
};
  • fwd 第 0 步:前腿到 90 + 10 = 100°,后腿到 90 - 30 = 60°;
  • fwd 第 1 步:前腿到 90 - 15 = 75°,后腿到 90 + 30 = 120°。

两腿相位差正好相反(一前一后交叉摆动),模拟虫类爬行时的对角步态。rev 则是 fwd 的对称反转。

step() 的状态机逻辑

Bug.prototype.step = function(opts) {
  var dir, move, last, front, rear, step;

  opts = opts || {};

  // Get last move from history if any history exists
  // Provide a "fake" history if needed (first call)
  last = this.history.length ?
    this.history[this.history.length - 1] : {
      step: 1
    };

  // increment the last step
  step = last.step + 1;

  // If step is too high, step back to 0
  if (step > 1) {
    step = 0;
  }

  // Derive direction if provided,
  // defaults to fwd
  dir = opts.dir || "fwd";

  // Derive position° for next move
  move = Bug.STEP_MAP[dir][step];

  // Assign position° from center
  front = 90 + move[0];
  rear = 90 + move[1];

  // Write position° to servos
  this.front.to(front);
  this.rear.to(rear);

  // Allow half step or full if provided,
  // defaults to full
  // enum(false|null|undefined)
  if (!opts.half) {
    // Wait one second and move servos back to
    // center idling position, 90°
    setTimeout(function() {
      this.idle();
    }.bind(this), 1000);
  }

  // Push a step into history array;
  // will be used as a reference for the subsequent step
  this.history.push({
    dir: dir,
    step: step,
    front: front,
    rear: rear
  });
};

step() 的内部流程是一个经典的两态步态机:

  1. 读取上次步序:history 为空(首次调用)时用假历史 { step: 1 } 兜底;
  2. 步序翻转:step = last.step + 1,超过 1 则回 0,实现 0 → 1 → 0 → 1… 的交替摆动;
  3. 查表求角:move = Bug.STEP_MAP[dir][step],再以 90° 为中位叠加偏移得到前后腿目标角;
  4. 写舵机:this.front.to(front); this.rear.to(rear);
  5. 完整步 vs 半步:若 opts.half 为真(false | null | undefined 之外的合法值),不调度回中动作,保持两腿在当前位置,用于连续运动;否则 1 秒后自动 idle() 回中;
  6. 记录历史:把 dir / step / front / rear 压入 history,作为下一步计算的参照。

step() 背后:Servo.prototype.to 的底层语义

step() 全部依赖 five.Servo 的 to() 方法。从 lib/servo.js 源码看,to(degrees) 在简单数值模式下会执行:

// Enforce limited range of motion
degrees = Fn.constrain(degrees, this.range[0], this.range[1]);

即目标角会先被 constrain 到舵机 range 区间内,再做 offset 偏移与可选的角度翻转(invert),最后通过 this.update(degrees) 下发到 IO 层(Firmata 的 servoWrite)。同时,to() 把每次写入的 { timestamp, degrees, target } 记入内部 history(最多保留最近 5 条),并暴露 last、position 等只读属性(lib/servo.js)。

这也解释了 Bug 类中两个值得一提的设计:

  • Bug 用自己维护的 history 记录步态,而 Servo 实例内部另有写入历史(history/last/position),两者职责不同,互不干扰;
  • to() 返回 this 实例支持链式调用,但 Bug 的 step() 有意不返回,刻意弱化链式写法。

回中与停止:idle() 和 stop()

idle():回中并中断运动

Bug.prototype.idle = function() {
  // If the bug is actually in motion,
  // stop the servo intervals
  if (this.isMoving) {
    this.stop();
  }

  // set to center position°
  this.front.to(90);
  this.rear.to(90);
};

idle() 有两个动作:若正在运动则先 stop() 清掉定时器,再把前后腿都写到 90°(中位)。对照 lib/servo.js 中 center() 的实现 this.to(Math.abs((this.range[0] + this.range[1]) / 2)),可推断「90° 即默认中位」这一约定来自默认 range = [0, 180] 的几何中心;若为舵机配置了非对称 range,center() 会按区间中点计算,而本例直接写 90° 与默认区间中点一致。

stop():清理定时器

Bug.prototype.stop = function() {
  Object.keys(this.intervals).forEach(function(key) {
    if (this.intervals[key]) {
      clearInterval(this.intervals[key]);
    }
  }, this);
};

stop() 遍历 intervals 表中 fwd、rev 两个键,非空即 clearInterval,实现立即刹车。这正是「定时器句柄统一登记在表中」这一设计的好处:无论哪个方向在跑,一次调用即可全部清除。

连续运动:fwd() 与 rev() 的定时器调度

Bug 的前进/后退由一段「遍历数组、按名字批量生成原型方法」的代码实现:

[
  /**
   * fwd Move the bug forward continuously
   * @return {Bug}
   */
  "fwd",

  /**
   * rev Move the bug backwards continuously
   * @return {Bug}
   */
  "rev"

].forEach(function(dir, k) {

  Bug.prototype[dir] = function() {

    this.isMoving = true;

    this.intervals[dir] = setInterval(function() {
      this.step({
        dir: dir,
        half: true
      });
    }.bind(this), 750);

    // //return this;
  };
});

这里包含两个可复用的模式:

  1. 元编程生成方法:用一个字符串数组 ["fwd", "rev"] 声明方法名,forEach 循环里动态挂载 Bug.prototype[dir],避免重复手写两个几乎相同的函数;
  2. 半步 + 定时间隔 = 连续爬行:每 750ms 触发一次 step({ dir, half: true })。由于 half: true 不会触发 idle() 回中,舵机会在 0/1 两步之间持续交替,形成连贯的爬行动作。isMoving = true 则保证任何时刻调用 idle() 都能正确停住。

setInterval 的句柄被写入 this.intervals[dir],正是为了配合上面的 stop() 做统一清理。从源码结构看,fwd()/rev() 被定义为「启动后就无限循环」的持续动作,而 step() 是「单步可控」的原子动作——这构成了 Bug 的两级控制 API。

在 Johnny-Five 的 REPL 中实时操控 Bug

主程序入口在板子 ready 事件回调中:

five.Board().on("ready", function() {
  var bug, ranges, servos;

  bug = new Bug({
    front: new five.Servo(9),
    rear: new five.Servo(10)
  });

  // Inject the Servo Array into the REPL as "s"
  this.repl.inject({
    bug: bug,
    s: new five.Servos()
  });

  // bug.step();
});

REPL 注入机制

Johnny-Five 在 Board 初始化时会自动开启 REPL 会话(见 lib/board.js),而 this.repl.inject({...}) 会把对象注入到 REPL 的上下文,使运行期可直接在终端交互控制。inject 的实现位于 lib/repl.js:

inject(obj) {
  Object.keys(obj).forEach(function(key) {
    Object.defineProperty(
      this.context, key, Object.getOwnPropertyDescriptor(obj, key)
    );
  }, this);
}

它通过 Object.defineProperty 把传入对象各键的定义描述符原样复制到 REPL 的 context 上(context 在 lib/repl.js 中被初始化为 Node 原生 repl.start() 的上下文)。因此本例运行后会得到两个全局可用变量:

  • bug:刚构建的 Bug 实例,可调用 bug.fwd()、bug.rev()、bug.step()、bug.idle()、bug.stop();
  • s:new five.Servos() 生成的全板舵机集合,便于直接查看/控制所有舵机。

运行期交互示例

>> bug.step();        // 让机器人迈一步(默认 fwd,完整步)
>> bug.fwd();         // 持续前进,每 750ms 一个半步
>> bug.idle();        // 立即停住并回到 90° 中位
>> bug.rev();         // 持续后退
>> bug.stop();        // 立即停止

关闭 REPL

如果不希望自动开启 REPL,可以在 Board 构造参数中显式禁用:new five.Board({ repl: false })。从 lib/board.js 源码可确认 options.repl 的存在与默认开启行为;lib/repl.js 中的 Repl.isBlocked 静态标志则用于多 Board 场景下的 REPL 互斥管理。

扩展思路:从两足 Bug 到四足机器人

示例注释明确预留了四足扩展路径。把 Bug 扩展为四足时,可遵循以下要点:

  1. 挂载四只舵机:为 front / rear / left / right 四个部件各传一个 five.Servo 实例,左右腿建议配置收窄的 range(如 [70, 115]),避免机械越界;
  2. 扩展步态表:将 STEP_MAP 中的 [前腿偏移, 后腿偏移] 扩展为包含四腿偏移的四元组,并重新设计左右交替的相位;
  3. 统一调度:让 step() 继续作为唯一的写角入口,fwd()/rev() 的 750ms 定时器逻辑可原样复用;
  4. 依赖注入:保持「构造器接收 servos 对象」的注入方式,使机器人实例与硬件引脚解耦,方便切换测试平台。

小结

docs/bug.md 与 eg/bug.js 展示了 Johnny-Five 生态中一个精炼的机器人封装范式:

  • 面向对象封装:构造函数注入舵机实例 + 原型方法提供动作 API,机器人逻辑与硬件细节分离;
  • 步态状态机:STEP_MAP 查表 + history 记录 + 步序翻转,用极简代码实现两态交替爬行;
  • 连续运动调度:intervals 句柄表 + setInterval 半步驱动,配合 idle()/stop() 实现可随时中断的持续运动;
  • REPL 注入:利用 board.repl.inject() 把实例暴露到终端,实现免重启的实时调试与操控。

对希望深入学习的读者,建议对照阅读:

以此为基础,你可以继续结合 servo-animation.md、servo-array.md 等文档,把 Bug 从「定时器步态」升级为基于 Animation 的平滑插值运动,构建更自然的多足行走机器人。

登录后查看全文
johnny-five