从Kiva到Geek+：货到人系统与多AGV路径规划实战

简介：这份PDF资料围绕极智嘉CEO郑勇的创业经历与行业判断展开，面向关注智能物流、仓储机器人与自动化系统的从业者、研究者及创业者，帮助读者理解“货到人”模式的本质与机器人改造物流业的技术路径。资源包共1个PDF文件，大小约3.92MB，内容以人物访谈与行业分析为主，适合作为机器人、机器学习与深度学习在物流场景落地的参考文献。资料中详细梳理了Kiva系统与AGV的区别、极智嘉四位清华技术男的团队组建过程、2015年双十一登陆天猫超市仓库的实战考验，以及拣选系统在效率与准确度上的优化思路，同时点出高成本与技术壁垒两大行业难题。目前已有205人学习下载，读者可从中获得物流自动化赛道的创业视角、技术选型逻辑与团队协作经验，对理解智能仓储的商业化落地具有专业指导价值。

1. 从 Kiva 到 Geek+：物流机器人到底在替谁干活

仓库里最贵的从来不是机器人，而是拣货员每天走的那些路。一个传统电商仓，拣货员一天在货架间来回走十几公里，真正伸手拿货的时间不到三分之一，剩下的全耗在“走过去”和“找位置”上。Kiva 当年干的事，本质就是把“人走到货”翻转成“货走到人”——货架被顶起来送到工作站，人站着不动，货自己过来。Geek+ 郑勇那句“Kiva 只是货到人的一种”，说的不是 Kiva 不行，而是别把一种形态当成终点：货到人是一类解法，机器人改变物流业靠的是把搬运、拣选、分拣、装卸这些环节重新拆解，再用不同形态的机器人去填。

这篇笔记面向三类人：正在做智能物流课程设计的学生、准备给仓库上 AGV 的工程师、以及想搞清楚“货到人”和“AGV 调度”到底怎么落地的人。我会从货到人的系统结构讲起，落到 AGV 路径规划、调度参数、仿真验证，最后给一套能照着复现的最小方案。不吹概念，只讲怎么跑通、参数怎么调、哪里会翻车。

2. 货到人系统的三层结构：机器人、货架、工作站怎么配合

2.1 为什么“货到人”不是买几台 AGV 就完事

很多人第一次接触智能物流，以为货到人就是买一批 AGV，让它们把货架顶到人面前。真上手才发现，AGV 只是执行层，上面还有调度层和业务层。执行层负责走位、举升、避障；调度层决定哪台车去顶哪个货架、走哪条路、什么时候回充电桩；业务层对接 WMS，决定订单怎么拆、波次怎么排、工作站怎么分配。三层缺一层，系统就退化成“遥控小车搬货”，效率还不如人工。

Kiva 的经典结构是：货架底部有二维码，地面也铺二维码，AGV 靠底部摄像头读码定位，顶起货架后沿二维码网格走。Geek+ 早期方案类似，后来加入 SLAM 激光导航，减少地面二维码依赖。这两种路线的差别直接决定部署成本和维护难度：二维码方案定位精度高、成本低，但地面磨损或二维码脏了就要停线；SLAM 方案部署灵活，但动态环境里定位漂移是玄学，调参能调到你怀疑人生。

常见做法是混合：主通道用二维码保证精度，边缘区域用 SLAM 补盲。我一般会建议新项目先跑二维码方案，把调度逻辑跑通，再考虑加 SLAM。因为调度没跑通之前，定位再准也没用——车会堵在一起，或者空跑。

2.2 一个最小货到人系统的组成清单

要复现一个能跑的货到人 demo，不需要真仓库。用仿真平台就能验证调度和路径规划。下面是我常用的最小组成：

这张表里最容易被低估的是“交通管制”。多台 AGV 在窄通道里会车，如果没有让行规则，死锁是必然的。常见做法是给每个路段加方向锁，或者用时间窗预约。我见过一个课程设计，路径规划用 A* 跑得挺好，一上 5 台车就全堵在十字路口，最后加了一个“路口一次只允许一台车进入”的规则才跑通。

2.3 从订单到机器人动作的完整链路

一条订单进来，系统要做的事：拆单 → 分配工作站 → 找货架 → 派车 → 路径规划 → 举升 → 搬运 → 放下 → 回库。每一步都有参数。比如“找货架”不是随便找一个，而是找离工作站最近且当前没有被锁定的货架；“派车”要考虑车辆当前电量、位置、是否空闲。这些策略直接决定系统吞吐量。

我一般会先用一个简化策略跑通：订单按顺序处理，货架按距离排序，车辆按空闲时间排序。跑通之后再换更复杂的策略，比如基于拍卖的任务分配，或者用强化学习做多 AGV 路径规划。但别一上来就上强化学习，状态空间没设计好，训练出来的策略在仿真里能跑，换张地图就废了。

3. 用 A* 和交通管制跑通多 AGV 路径规划

3.1 栅格地图上的 A* 实现与参数

A* 是 AGV 路径规划里最稳的起点。它不挑地图，栅格化之后就能跑。下面是一个最小实现，输入是二维栅格、起点、终点，输出路径点列表。

import heapq def a_star(grid, start, goal): # grid: 0 可走，1 障碍 rows, cols = len(grid), len(grid[0]) open_set = [(0, start)] came_from = {} g_score = {start: 0} f_score = {start: heuristic(start, goal)} while open_set: _, current = heapq.heappop(open_set) if current == goal: return reconstruct(came_from, current) for dx, dy in [(1,0),(-1,0),(0,1),(0,-1)]: neighbor = (current[0]+dx, current[1]+dy) if not (0 <= neighbor[0] < rows and 0 <= neighbor[1] < cols): continue if grid[neighbor[0]][neighbor[1]] == 1: continue tentative_g = g_score[current] + 1 if tentative_g < g_score.get(neighbor, float('inf')): came_from[neighbor] = current g_score[neighbor] = tentative_g f_score[neighbor] = tentative_g + heuristic(neighbor, goal) heapq.heappush(open_set, (f_score[neighbor], neighbor)) return None def heuristic(a, b): return abs(a[0]-b[0]) + abs(a[1]-b[1]) def reconstruct(came_from, current): path = [current] while current in came_from: current = came_from[current] path.append(current) return path[::-1]

这段代码里，heuristic用曼哈顿距离，适合四邻域移动。如果允许斜走，换成欧几里得距离。g_score是起点到当前点的实际代价，f_score是实际代价加启发式。参数上唯一要调的是启发式权重：权重设 1 是最优路径但慢，设大于 1 是加权 A*，路径可能不是最短但搜得快。仓库地图通常不大，权重设 1 就够。

注意：A* 只解决单台车的路径。多台车同时跑，每台车都按自己的最短路径走，必然在交叉口冲突。所以下一步要加交通管制。

3.2 时间窗预约：让多台 AGV 不打架

交通管制最简单的方法是时间窗预约。每台车规划路径时，把路径上的每个栅格和到达时间登记到一张全局表里。如果某个栅格在某个时间段已经被占用，就换一条路或者等一会儿。

class TrafficManager: def __init__(self): self.reservations = {} # (row, col) -> list of (start_time, end_time, agv_id) def reserve(self, path, agv_id, start_time=0, speed=1): # speed: 每步耗时 reservations = [] t = start_time for cell in path: if cell in self.reservations: for (s, e, aid) in self.reservations[cell]: if aid != agv_id and not (t + speed <= s or t >= e): return None # 冲突 reservations.append((cell, t, t + speed, agv_id)) t += speed for (cell, s, e, aid) in reservations: self.reservations.setdefault(cell, []).append((s, e, aid)) return reservations

这个实现很粗糙，但能跑。speed是每走一格的时间，实际项目里要根据 AGV 速度和栅格大小换算。冲突检测那里，如果时间重叠就返回 None，调用方重新规划或者让车等待。常见坑是：预约之后没有释放机制，车走完了格子还占着，后面车永远等不到。所以要有release方法，按时间清理过期预约。

更稳的做法是预留安全间隔，比如每格前后各留 0.5 秒。我一般会把speed设成实际通过时间的 1.2 倍，留一点余量。不然仿真里不撞，真机上因为通信延迟就撞了。

3.3 死锁排查：车在路口互相等怎么办

死锁是多 AGV 最烦的问题。现象是几台车在路口互相等，谁也不走。原因通常是预约顺序不对：A 车占了路口等 B 车让路，B 车占了另一个格子等 A 车让路，循环等待。

解决办法有三个层次。第一，路口加方向锁，一次只允许一个方向的车进入。第二，给每台车设优先级，低优先级车主动退让。第三，用集中式调度，所有车由同一个调度器分配路径，避免分布式抢路。课程设计里最省事的是第一种，加一个“路口互斥”规则，实现简单，效果立竿见影。

排查的时候，先看日志里每台车的预约表，找到循环等待的格子。然后看调度器有没有超时机制——如果一台车等超过 N 秒，就重新规划或者强制让行。我一般会设 5 秒超时，超过就触发重规划。这个参数别设太小，否则车会频繁重规划，反而更慢。

4. 仿真验证：用 ExtendSim 或自研脚本跑吞吐量

4.1 仿真平台怎么选：ExtendSim、ROS2 还是自研

物流规划课程设计里常见 ExtendSim，因为它自带离散事件仿真模块，拖拖拽拽就能搭出排队网络。但 ExtendSim 对 AGV 运动学支持弱，适合验证调度策略和吞吐量，不适合验证路径规划。ROS2 适合验证运动控制和多机通信，但搭一个仓库场景要写不少代码。自研脚本最灵活，但可视化差。

我的建议：先用自研脚本跑调度逻辑，验证任务分配和路径规划；再用 ExtendSim 或类似工具跑吞吐量，看系统瓶颈在哪。两者结果对不上，通常是仿真粒度不同——自研脚本按步进，ExtendSim 按事件。

4.2 吞吐量指标：每小时拣选次数怎么算

吞吐量是货到人系统的核心指标。算法是：工作站数量 × 每个工作站每小时完成的订单行数。但实际受限于 AGV 数量、路径长度、举升时间、充电策略。

一个简化模型：假设 10 台 AGV，平均搬运一趟 60 秒（含举升和放下），工作站 2 个，每个工作站同时处理 1 台车。那么每小时每台 AGV 能跑 60 趟，10 台就是 600 趟。但工作站只有 2 个，每趟在工作站停留 20 秒，所以工作站每小时最多处理 2 × 180 = 360 趟。瓶颈在工作站，不在 AGV。

这个计算很粗，但能帮你快速判断该加车还是加工作站。常见误区是拼命加 AGV，结果全堵在工作站门口。我一般会先算工作站容量，再反推 AGV 数量。

4.3 用 Python 跑一个最小仿真循环

下面是一个最小仿真循环，模拟 5 台 AGV、2 个工作站、随机订单。

import random import time class AGV: def __init__(self, id): self.id = id self.pos = (0, 0) self.busy = False self.task = None class WarehouseSim: def __init__(self, num_agv=5, num_station=2): self.agvs = [AGV(i) for i in range(num_agv)] self.stations = [0] * num_station # 0 空闲，1 占用 self.time = 0 self.completed = 0 def step(self): self.time += 1 # 随机生成订单 if random.random() < 0.3: self.assign_task() # 推进 AGV for agv in self.agvs: if agv.busy: agv.task['remaining'] -= 1 if agv.task['remaining'] <= 0: agv.busy = False self.completed += 1 self.stations[agv.task['station']] = 0 agv.task = None def assign_task(self): free_agv = [a for a in self.agvs if not a.busy] free_station = [i for i, s in enumerate(self.stations) if s == 0] if free_agv and free_station: agv = free_agv[0] station = free_station[0] agv.busy = True agv.task = {'station': station, 'remaining': random.randint(30, 90)} self.stations[station] = 1 sim = WarehouseSim() for _ in range(3600): sim.step() print(f"1 小时完成 {sim.completed} 趟")

这段代码里，remaining是搬运耗时，随机 30 到 90 步。assign_task是最简单的先到先得。跑出来你会发现，如果订单生成太快，工作站很快占满，AGV 空闲但没法干活。这时候要么加工作站，要么限制订单生成速率。参数上，0.3是订单到达概率，调大能压测系统极限。

5. 避坑与排查：货到人项目里最容易翻车的 5 个点

5.1 二维码定位在真实仓库里失效

现象：仿真里跑得好好的，一到真实仓库，AGV 经常读不到码，定位跳变。原因：地面二维码被叉车压花、灰尘覆盖，或者灯光反光导致摄像头曝光过度。解决：定期清洁二维码，加辅助定位（如惯性导航），或者改用 SLAM 方案。我一般会在关键路口加反光板，用激光定位兜底。

5.2 多 AGV 通信延迟导致撞车

现象：仿真里不撞，真机上两台车在路口同时进入，撞了。原因：仿真里通信是瞬时的，真机上 Wi-Fi 有延迟，预约表更新不及时。解决：加安全间隔，每格预约前后各留 0.5 秒；或者用集中式调度，所有决策在一个控制器里做，减少通信往返。

5.3 任务分配不均导致部分车过载

现象：有的车一直跑，有的车一直闲。原因：任务分配策略只看空闲状态，没看车辆位置和电量。解决：分配任务时加距离权重和电量权重，优先派离货架近且电量充足的车。常见做法是算一个综合得分：距离 × 0.6 + 电量 × 0.4，取最高分。

5.4 充电策略没设计好，车全没电了

现象：跑着跑着，所有车都去充电，系统停摆。原因：充电阈值设得太低，或者充电桩数量不够。解决：设两个阈值，低于 30% 强制充电，低于 50% 且空闲时机会充电。充电桩数量按 AGV 数量的 1/5 配置。我见过一个项目，10 台车配 1 个充电桩，结果每天下午集体趴窝。

5.5 仿真和真实吞吐量对不上

现象：仿真说每小时 500 单，实际只有 200 单。原因：仿真忽略了拣货员操作时间、货架举升时间、异常处理时间。解决：在仿真里加这些时间，或者用实际数据校准。我一般会把仿真结果打七折作为真实预期，留出余量。

6. 进阶：用强化学习做多 AGV 路径规划值不值得

多 AGV 路径规划用强化学习，这两年很热。但我的血泪经验是：状态空间没设计好，训练出来的策略换张地图就废。如果你只是想跑通课程设计，A* 加交通管制足够。如果你想发论文或者探索前沿，可以试，但要有心理准备。

一个可行的切入点是：把每个路口当成智能体，用 Q-learning 学让行策略。状态是各方向等待车辆数，动作是放行哪个方向。奖励是负的累计等待时间。这样状态空间小，训练快，而且换地图只要重新训练路口策略，不用重训整个系统。

import numpy as np class IntersectionAgent: def __init__(self, n_directions=4): self.q_table = np.zeros((5, 5, 5, 5, n_directions)) # 每个方向等待数 0-4 self.lr = 0.1 self.gamma = 0.9 self.epsilon = 0.1 def choose_action(self, state): if np.random.random() < self.epsilon: return np.random.randint(len(state)) return np.argmax(self.q_table[state]) def update(self, state, action, reward, next_state): best_next = np.max(self.q_table[next_state]) self.q_table[state][action] += self.lr * (reward + self.gamma * best_next - self.q_table[state][action])

这个实现很粗糙，但能跑。state是四个方向的等待车辆数，每个维度离散成 0 到 4。reward可以设为负的等待时间。训练几百轮之后，路口通行效率会比固定规则好。但注意：Q 表大小是 5^4 × 4 = 2500，不大，训练快。如果方向数增加，状态空间指数增长，就要换函数逼近了。

验证方法：固定随机种子，对比强化学习策略和固定规则策略的累计等待时间。如果强化学习没有明显优势，就别硬上。我一般会跑 10 次取平均，差异小于 10% 就认为不值得。

最后说个习惯：我每次做物流机器人方案，都会先画一张流程图，把订单、货架、AGV、工作站、充电桩的关系标清楚，再动手写代码。图没画清楚，代码一定返工。希望帮到你。

本文还有配套的精品资源，点击获取