最新的swoole6+io_uring 工业现场边缘计算与协议转换网关
·
一套工业现场边缘计算 + 协议转换网关的完整方案(Swoole 6 +
io_uring)。和上一套"百万设备接入"不同,这套的核心是:南向把各种工业协议(Modbus/MQTT…)采集进来 → 统一成内部点位模型 → 本地边缘计算(告警/过滤/公式)→ 北向上报云端,断网还能续传。
先讲架构,再给完整代码,最后逐段大白话。
---
一、大白话讲整体:这网关到底干啥?
工厂车间里设备说的"语言"五花八门:PLC 说 Modbus、有的传感器说 MQTT、老仪表说
RTU……云平台只想要一份干净统一的数据。这台网关就是车间和云之间的翻译官+ 小管家:
工业现场设备(说各种"方言")
┌─────────┬──────────┬───────────┐
│ PLC │ 智能仪表 │ 传感器 │
│ Modbus │ MQTT │ Modbus │
└────┬─────┴────┬─────┴─────┬─────┘
│ ①南向采集(协程轮询/订阅)
▼ ▼ ▼
┌───────────────────────────────────────┐
│ 边缘网关 (Swoole 6) │
│ │
│ ②协议转换 →统一点位模型(Swoole\Table)│
│ tag: 设备.点位 = 值/时间/质量 │
│ │
│ ③边缘计算引擎 │
│ - 死区过滤(变化不大就不上报) │
│ - 阈值告警(超温/超压立刻报) │
│ - 公式换算(原始值→工程值) │
│ │
│ ④北向上报(MQTT/HTTP 到云) │
│ ⑤断网续传(io_uring 落盘缓存,恢复重发) │
└───────────────────────────────────────┘
│ ⑥北向
▼
云平台 / SCADA / 大数据
为什么要"边缘计算"? 不能啥数据都往云上怼。一个温度传感器每秒采 10 次,99%
时间温度没变,全传上去既费流量又把云压垮。边缘网关在本地先过滤、算、判断,只把"有用的"和"出事的"传上去。
io_uring 在这干啥? 工厂网络经常抖动断网。一断网,数据不能丢,得先飞快地写到本地磁盘排队;网络恢复了再按顺序补传。io_uring
让这个"狂写磁盘"的动作异步、不卡采集主流程。
---
二、两个关键技术点(先懂)
1. Swoole 6 多线程 + 协程
每个南向设备开一个协程去轮询,几百上千个设备的轮询互不阻塞;统一点位表用 Swoole\Table
放共享内存,采集线程写、上报线程读。
2. io_uring
配置 iouring_entries + Runtime::enableCoroutine(... | SWOOLE_HOOK_FILE),之后协程里写本地缓存文件自动走内核级异步
IO,断网续传的"落盘"动作不拖累采集。
---
三、完整代码
1)主网关 EdgeGateway.php
<?php
declare(strict_types=1);
use Swoole\Process;
use Swoole\Table;
use Swoole\Timer;
use Swoole\Coroutine;
use Swoole\Runtime;
use function Swoole\Coroutine\run;
/**
* 工业现场边缘计算与协议转换网关 (Swoole 6 + io_uring)
* 运行: php EdgeGateway.php
* 环境: Linux 内核>=5.10, Swoole>=6.0, PHP>=8.1
*/
final class EdgeGateway
{
/** 统一点位实时表: key = "设备.点位", 共享内存 */
public Table $points;
/** 上报缓冲(变化的点)队列, 线程安全 */
private \Swoole\Thread\Queue $reportQueue;
/** 设备采集配置(实际可来自配置文件/数据库) */
private array $devices;
/** 边缘计算规则 */
private array $rules;
public function __construct()
{
$this->initPointTable();
$this->loadConfig();
}
/* ---------- 统一点位表 ---------- */
private function initPointTable(): void
{
$this->points = new Table(65536);
$this->points->column('value', Table::TYPE_FLOAT); // 工程值
$this->points->column('raw', Table::TYPE_FLOAT); // 原始值
$this->points->column('ts', Table::TYPE_INT); // 采集时间
$this->points->column('quality', Table::TYPE_INT); // 质量:1好0坏
$this->points->create();
}
/* ---------- 加载配置(南向设备 + 边缘规则) ---------- */
private function loadConfig(): void
{
// 南向: 要采集哪些设备、点位、地址
$this->devices = [
[
'name' => 'plc1', // 设备名
'protocol' => 'modbus_tcp', // 协议
'host' => '127.0.0.1',
'port' => 1502,
'unit_id' => 1,
'interval' => 1000, // 轮询周期(毫秒)
'points' => [
// 点位名 => [功能码, 起始寄存器, 数量, 倍率, 偏移]
'temp' => ['fc' => 3, 'addr' => 0, 'qty' => 1, 'scale' => 0.1, 'offset' => 0],
'pressure' => ['fc' => 3, 'addr' => 1, 'qty' => 1, 'scale' => 0.01, 'offset' => 0],
],
],
];
// 边缘计算规则
$this->rules = [
// 死区: 变化小于这个值就不上报(降噪降流量)
'deadband' => [
'plc1.temp' => 0.5,
'plc1.pressure' => 0.05,
],
// 阈值告警: 超过立刻报警
'alarm' => [
'plc1.temp' => ['max' => 80.0, 'min' => -10.0],
'plc1.pressure' => ['max' => 10.0, 'min' => 0.0],
],
];
}
/* ================= 启动 ================= */
public function start(): void
{
// 开协程 + io_uring 文件钩子
Runtime::enableCoroutine(SWOOLE_HOOK_ALL | SWOOLE_HOOK_FILE);
$this->reportQueue = new \Swoole\Thread\Queue();
echo "[边缘网关启动]\n";
run(function () {
// ①南向: 每个设备一个采集协程
foreach ($this->devices as $dev) {
Coroutine::create(fn() => $this->southboundLoop($dev));
}
// ②北向: 上报协程(带断网续传)
Coroutine::create(fn() => $this->northboundLoop());
// ③断网恢复后, 补传本地缓存
Coroutine::create(fn() => $this->replayLoop());
});
}
/* ================= ①南向采集 + 协议转换 ================= */
/** 单个设备的采集循环 */
private function southboundLoop(array $dev): void
{
$collector = match ($dev['protocol']) {
'modbus_tcp' => new ModbusTcpCollector($dev),
// 'mqtt' => new MqttCollector($dev), // 可扩展
default => throw new \RuntimeException("不支持的协议 {$dev['protocol']}"),
};
while (true) {
try {
// 采一轮: 返回 [点位名 => 原始值]
$raws = $collector->poll();
foreach ($raws as $pname => $raw) {
$this->onPointData($dev, $pname, (float)$raw);
}
} catch (\Throwable $e) {
echo "[采集异常] {$dev['name']}: {$e->getMessage()}\n";
}
Coroutine::sleep($dev['interval'] / 1000);
}
}
/**
* 收到一个原始点位值 →协议转换 + 边缘计算
*/
private function onPointData(array $dev, string $pname, float $raw): void
{
$key = "{$dev['name']}.$pname";
$cfg = $dev['points'][$pname];
// ②协议转换/工程换算: 原始值 →工程值 = raw*scale + offset
$value = $raw * $cfg['scale'] + $cfg['offset'];
$now = time();
// 取上一次的值用于死区判断
$old = $this->points->get($key);
$oldValue = $old ? $old['value'] : null;
// 写入实时点位表(永远存最新值, 给本地展示/其他逻辑用)
$this->points->set($key, [
'value' => $value,
'raw' => $raw,
'ts' => $now,
'quality' => 1,
]);
// ③边缘计算
$this->edgeCompute($key, $value, $oldValue, $now);
}
/* ================= ③边缘计算引擎 ================= */
private function edgeCompute(string $key, float $value, ?float $oldValue, int $now): void
{
// ---- 阈值告警: 超限立刻进上报队列(告警不走死区过滤) ----
if (isset($this->rules['alarm'][$key])) {
$a = $this->rules['alarm'][$key];
if ($value > $a['max'] || $value < $a['min']) {
$this->reportQueue->push(json_encode([
'type' => 'alarm',
'point' => $key,
'value' => $value,
'ts' => $now,
'msg' => "超限! 当前=$value 范围=[{$a['min']},{$a['max']}]",
]));
echo "[告警] $key=$value 超限\n";
}
}
// ---- 死区过滤: 变化太小就不上报普通数据 ----
$deadband = $this->rules['deadband'][$key] ?? 0;
if ($oldValue !== null && abs($value - $oldValue) < $deadband) {
return; // 变化不够大, 丢弃, 不上报
}
// 通过死区 →进上报队列
$this->reportQueue->push(json_encode([
'type' => 'data',
'point' => $key,
'value' => $value,
'ts' => $now,
]));
}
/* ================= ④北向上报 + ⑤断网续传 ================= */
private function northboundLoop(): void
{
$uploader = new NorthboundUploader(
host: '127.0.0.1', port: 1883,
clientId: 'edge-gw-001', topic: 'factory/edge/up'
);
while (true) {
$msg = $this->reportQueue->pop(1.0); // 最多等1秒
if ($msg === null || $msg === false) {
continue;
}
// 尝试上报云端
if (!$uploader->publish($msg)) {
// 上报失败(断网) →io_uring 异步落盘排队
$this->bufferToDisk($msg);
}
}
}
/** 断网时把数据写本地缓存(走 io_uring 异步) */
private function bufferToDisk(string $msg): void
{
// 协程里写文件 →自动 io_uring 异步, 不阻塞
file_put_contents(
'/var/lib/edge/buffer.log',
$msg . "\n",
FILE_APPEND
);
}
/* ================= ⑥断网恢复后补传 ================= */
private function replayLoop(): void
{
$uploader = new NorthboundUploader(
host: '127.0.0.1', port: 1883,
clientId: 'edge-gw-001-replay', topic: 'factory/edge/up'
);
$bufFile = '/var/lib/edge/buffer.log';
while (true) {
Coroutine::sleep(10); // 每10秒检查一次有没有积压
if (!file_exists($bufFile) || filesize($bufFile) === 0) {
continue;
}
// 先探测云端通不通
if (!$uploader->isOnline()) {
continue;
}
// io_uring 异步读出整个缓存
$content = file_get_contents($bufFile);
$lines = array_filter(explode("\n", $content));
$failed = [];
foreach ($lines as $line) {
if (!$uploader->publish($line)) {
$failed[] = $line; // 又断了, 留着下次
}
}
// 把没传成功的写回去, 传成功的清掉
if ($failed) {
file_put_contents($bufFile, implode("\n", $failed) . "\n");
} else {
file_put_contents($bufFile, ''); // 全传完, 清空
echo "[续传] 缓存已全部补传完成\n";
}
}
}
}
(new EdgeGateway())->start();
---
2)Modbus TCP 采集器 ModbusTcpCollector.php(协议层手写)
<?php
declare(strict_types=1);
use Swoole\Coroutine\Client;
/**
* Modbus TCP 采集器: 协程客户端, 读保持寄存器(功能码03)
* Modbus TCP 帧 = MBAP头(7字节) + PDU
* MBAP: 事务ID(2) 协议ID(2,=0) 长度(2) 单元ID(1)
* PDU(读保持寄存器请求): 功能码(1) 起始地址(2) 数量(2)
*/
final class ModbusTcpCollector
{
private ?Client $conn = null;
private int $txId = 0;
public function __construct(private array $dev) {}
/** 采一轮, 返回 [点位名 => 原始值] */
public function poll(): array
{
$this->ensureConnected();
$result = [];
foreach ($this->dev['points'] as $pname => $cfg) {
$regs = $this->readHoldingRegisters(
$cfg['addr'], $cfg['qty']
);
// 单寄存器直接取值; 多寄存器可按需组成32位等
$result[$pname] = $regs[0] ?? 0;
}
return $result;
}
/** 确保连接可用, 断了就重连 */
private function ensureConnected(): void
{
if ($this->conn && $this->conn->isConnected()) {
return;
}
$this->conn = new Client(SWOOLE_SOCK_TCP);
$this->conn->set(['timeout' => 2.0]);
if (!$this->conn->connect($this->dev['host'], $this->dev['port'], 2)) {
throw new \RuntimeException("连不上 PLC {$this->dev['host']}:{$this->dev['port']}");
}
}
/** 读保持寄存器(功能码 0x03) */
private function readHoldingRegisters(int $addr, int $qty): array
{
$this->txId = ($this->txId + 1) & 0xFFFF;
$unitId = $this->dev['unit_id'];
// PDU: 功能码03 + 起始地址 + 数量
$pdu = pack('C', 0x03) . pack('n', $addr) . pack('n', $qty);
// MBAP: 事务ID + 协议ID(0) + 长度(unitId+pdu) + 单元ID
$mbap = pack('n', $this->txId) . pack('n', 0)
. pack('n', strlen($pdu) + 1) . pack('C', $unitId);
$this->conn->send($mbap . $pdu);
// 收响应
$resp = $this->conn->recv(2.0);
if ($resp === false || strlen($resp) < 9) {
throw new \RuntimeException("Modbus 无响应/响应过短");
}
// 跳过 MBAP(7) + 功能码(1)
$fc = ord($resp[7]);
if ($fc & 0x80) { // 最高位=1 是异常响应
throw new \RuntimeException("Modbus 异常码: " . ord($resp[8]));
}
$byteCount = ord($resp[8]); // 数据字节数
$data = substr($resp, 9, $byteCount); // 寄存器数据
// 每个寄存器2字节, 大端
$regs = array_values(unpack('n*', $data));
return $regs;
}
}
---
3)北向上报器 NorthboundUploader.php(精简 MQTT 客户端)
<?php
declare(strict_types=1);
use Swoole\Coroutine\Client;
/**
* 北向 MQTT 上报器(精简版 MQTT 3.1.1, QoS0)
* 只实现工业上报需要的 CONNECT + PUBLISH
*/
final class NorthboundUploader
{
private ?Client $conn = null;
private bool $connected = false;
public function __construct(
private string $host,
private int $port,
private string $clientId,
private string $topic,
) {}
/** 探测在线 */
public function isOnline(): bool
{
return $this->ensureConnected();
}
/** 发布一条消息, 成功 true / 失败(断网) false */
public function publish(string $payload): bool
{
if (!$this->ensureConnected()) {
return false;
}
$packet = $this->buildPublish($this->topic, $payload);
$ok = $this->conn->send($packet);
if ($ok === false) {
$this->connected = false;
return false;
}
return true;
}
/* ---- 连接(含 MQTT CONNECT 握手) ---- */
private function ensureConnected(): bool
{
if ($this->conn && $this->conn->isConnected() && $this->connected) {
return true;
}
$this->conn = new Client(SWOOLE_SOCK_TCP);
$this->conn->set(['timeout' => 3.0]);
if (!$this->conn->connect($this->host, $this->port, 3)) {
return false; // 断网
}
// 发 CONNECT
$this->conn->send($this->buildConnect($this->clientId));
$ack = $this->conn->recv(3.0);
// CONNACK: 0x20 0x02 0x00 0x00 (返回码0=成功)
if ($ack === false || strlen($ack) < 4 || ord($ack[3]) !== 0x00) {
return false;
}
$this->connected = true;
return true;
}
/* ---- 构造 MQTT CONNECT 报文 ---- */
private function buildConnect(string $clientId): string
{
$proto = $this->encodeStr('MQTT'); // 协议名
$level = chr(0x04); // 协议级别 3.1.1
$flags = chr(0x02); // clean session
$keep = pack('n', 60); // keepalive 60s
$payload = $this->encodeStr($clientId);
$vh = $proto . $level . $flags . $keep . $payload;
return chr(0x10) . $this->remainLen(strlen($vh)) . $vh;
}
/* ---- 构造 MQTT PUBLISH 报文(QoS0) ---- */
private function buildPublish(string $topic, string $payload): string
{
$vh = $this->encodeStr($topic) . $payload; // QoS0 无报文标识符
return chr(0x30) . $this->remainLen(strlen($vh)) . $vh;
}
/** MQTT 字符串: 2字节长度 + 内容 */
private function encodeStr(string $s): string
{
return pack('n', strlen($s)) . $s;
}
/** MQTT 剩余长度(变长编码) */
private function remainLen(int $len): string
{
$out = '';
do {
$b = $len % 128;
$len = intdiv($len, 128);
if ($len > 0) $b |= 0x80;
$out .= chr($b);
} while ($len > 0);
return $out;
}
}
---
4)测试用:模拟 Modbus TCP 从站 FakeSlave.php
<?php
declare(strict_types=1);
use Swoole\Server;
/** 假 PLC: 监听 1502, 收到读寄存器请求就回随机温度/压力 */
$server = new Server('127.0.0.1', 1502, SWOOLE_BASE, SWOOLE_SOCK_TCP);
$server->set(['worker_num' => 1]);
$server->on('Receive', function (Server $srv, int $fd, int $rid, string $data) {
if (strlen($data) < 12) return;
$txId = substr($data, 0, 2); // 事务ID原样返回
$unitId = $data[6];
$fc = ord($data[7]); // 功能码
$qty = unpack('n', substr($data, 10, 2))[1]; // 数量
if ($fc !== 0x03) return;
// 造数据: 温度=250~850(即25.0~85.0℃),压力随机
$regs = '';
for ($i = 0; $i < $qty; $i++) {
$regs .= pack('n', rand(250, 850));
}
$byteCount = chr($qty * 2);
$pdu = chr(0x03) . $byteCount . $regs;
$mbap = $txId . pack('n', 0) . pack('n', strlen($pdu) + 1) . $unitId;
$srv->send($fd, $mbap . $pdu);
});
echo "[假PLC] 监听 127.0.0.1:1502\n";
$server->start();
测试步骤(大白话):
1. 先跑假 PLC:php FakeSlave.php
2. (可选)起个 MQTT broker(如 mosquitto)在 1883,没有也行,会触发断网续传逻辑
3. 跑网关:php EdgeGateway.php
4. 你会看到网关每秒采集、温度超 80 报警、变化小的被死区过滤掉、断网时写本地缓存、恢复后补传。
---
四、逐段大白话解释
①南向采集为啥"一设备一协程"?
工厂可能有几百台 PLC,挨个同步去问"你温度多少"会排长队。每台 PLC 开一个协程,A 在等 PLC 回话时,B/C/D 照样在问别的
PLC,互不耽误。Swoole 协程让你用"同步的写法"写出"异步的效果"。
②协议转换的核心是"统一点位模型"
不管设备说 Modbus 还是 MQTT,采进来后我一律转成同一种格式:设备.点位 = {工程值, 原始值, 时间, 质量},存进
Swoole\Table。原始值(比如寄存器里的 750)要乘倍率加偏移变成工程值(75.0℃),这就是"协议转换/工程换算"。后面所有逻辑、上报
都只认这个统一格式,新增一种协议只要写个采集器,后面全不用改。
③死区过滤 = 省流量的关键
温度从 75.0 变到 75.1,这种小波动没意义。设了死区 0.5,变化没超过 0.5 就直接丢掉不上报。现场一个点每秒采 10
次,实际有效上报可能每分钟才几条,流量和云端压力降几十倍。
④阈值告警为啥不走死区?
告警是"出事了",再小的死区也不能拦。所以代码里告警单独一条路,只要超限立刻进上报队列,优先级最高。
⑤Modbus 是手写的字节协议
Modbus TCP 就是一串规定好的字节:前 7 字节是"信封"(MBAP 头),后面是"内容"(功能码+地址+数量)。pack('n', ...)
就是把数字打成 2 字节大端。回包同样按字节切开取数据。工业协议本质都是这种"按字节约定",看懂一个就懂一类。
⑥北向用 MQTT,我精简手写了
MQTT 是工业上云的事实标准。完整 MQTT 很复杂,但上报只需要两个动作:CONNECT(连上 broker)和
PUBLISH(发消息)。我只实现这俩、用 QoS0(发了就行),代码就很短。生产想要 QoS1/重连/遗嘱,换成成熟库(如 simps/mqtt)即可。
⑦io_uring 在断网续传里怎么发力?
网络一断,数据不能丢,得疯狂往本地磁盘写排队。普通写文件会阻塞采集协程。开了 SWOOLE_HOOK_FILE + iouring_entries
后,协程里 file_put_contents 自动走 io_uring 内核异步,写盘的同时采集照常跑。网络恢复后 replayLoop 用 io_uring
异步读出来按顺序补传,传成功的清掉、又失败的留着下次——保证断网期间数据一条不丢。
⑧三个协程各管一摊,互不干扰
- 采集协程:只管把数据采进来、算一下、塞队列。
- 上报协程:只管从队列拿、发云端、失败就落盘。
- 续传协程:只管定时看本地有没有积压、网通了就补。
用 Swoole\Thread\Queue 在它们之间传数据,解耦,任何一环慢了或挂了都不会连累其他环。
---
五、上线注意事项(大白话)
# 1. 本地缓存目录要先建好、给够磁盘(断网越久缓存越大)
mkdir -p /var/lib/edge /var/log
# 2. 边缘网关通常跑在工控机/ARM盒子上, 内核要够新才有io_uring
uname -r # 需 >= 5.10, 建议 5.15+
# 3. 串口Modbus RTU设备: 把ModbusTcpCollector换成读 /dev/ttyS* 的串口采集
# (Swoole可用Coroutine\System::fread读串口fd, 或走Modbus网关转TCP)
# 4. 配置建议外置成 YAML/JSON 文件, 改设备点位不用动代码
- 数据质量(quality)位:采集失败时把 quality 置 0,云端就知道这值不可信,别拿坏数据去算。
- 采集周期别贪快:PLC 处理慢,1 秒一轮通常够;太快会把 PLC 问死。
- 边缘规则可热更新:把 rules 放共享内存表或定时从配置中心拉取,改告警阈值不用重启。
---
需要我继续补哪块?可选方向:
- Modbus RTU 串口采集(读 /dev/ttyUSB0)
- OPC UA / 西门子 S7 协议采集器
- 边缘规则脚本化(支持自定义公式/联动控制,比如"温度>80 就下发停机命令")
- 本地时序数据库缓存 + 边缘可视化
- 多网关 + 云端配置下发的完整闭环
说方向就行,我直接给完整代码。
更多推荐
所有评论(0)