一套工业现场边缘计算 + 协议转换网关的完整方案(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 就下发停机命令")
  - 本地时序数据库缓存 + 边缘可视化
  - 多网关 + 云端配置下发的完整闭环

  说方向就行,我直接给完整代码。
Logo

聚焦RDK与具身智能,汇集机器人开发教程、开源案例和技术交流

更多推荐