跳转至

TCP

一、TCP 概述

TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它主要用于在不可靠的网络环境中提供稳定的数据传输服务，确保数据能够按照顺序、无错误地到达接收端。TCP 通过三次握手建立连接，使用滑动窗口进行流量控制，以及通过校验和、确认应答、超时重传等机制来保证数据的可靠性。它是互联网协议套件（TCP/IP 协议族）的核心组成部分，广泛应用于各种网络应用中。

工作原理：

1.1 连接建立：TCP 协议使用三次握手协议来建立连接。

  • 客户端发送一个 SYN（同步序列编号）报文给服务端，并携带一个随机生成的初始序列号。
  • 服务端收到 SYN 报文后，发送一个 SYN+ACK（同步序列编号 + 确认应答）报文给客户端，表示确认收到了客户端的 SYN 报文，并携带自己的初始序列号。
  • 客户端收到服务端的 SYN+ACK 报文后，发送一个 ACK（确认应答）报文给服务端，表示确认收到了服务端的 SYN+ACK 报文。至此，TCP 连接建立完成。

1.2 数据传输：

在连接建立后，双方就可以开始传输数据了。TCP 协议会将应用层发送的数据分割成适当长度的报文段（通常受该计算机连接的网络的数据链路层的最大传输单元 MTU 的限制），并为每个报文段分配一个序号。接收端在收到报文段后，会按照序号进行排序，并发送确认应答（ACK）给发送端。如果发送端在合理的往返时延（RTT）内未收到确认应答，则会重传对应的报文段。

1.3 连接释放：TCP 协议使用四次挥手协议来终止连接。

  • 客户端发送一个 FIN（结束）报文给服务端，表示自己想要关闭连接。
  • 服务端收到 FIN 报文后，发送一个 ACK 报文给客户端，表示确认收到了客户端的 FIN 报文。此时，客户端到服务端的连接关闭，但服务端到客户端的连接仍然打开。
  • 服务端在发送完所有剩余数据后，也发送一个 FIN 报文给客户端，表示自己也想要关闭连接。
  • 客户端收到服务端的 FIN 报文后，发送一个 ACK 报文给服务端，表示确认收到了服务端的 FIN 报文。至此，TCP 连接完全关闭。

二、准备硬件环境

“古人云：‘工欲善其事，必先利其器。’在深入介绍本功能示例之前，我们首先需要确保以下硬件环境的准备工作已经完成。”

参考：硬件环境清单，准备以及组装好硬件环境。

三、准备软件环境

“凡事预则立，不预则废。”在详细阐述本功能示例之前，我们需先精心筹备好以下软件环境。

3.1 合宙模组相关

“凡事预则立，不预则废。”在详细阐述本功能示例之前，我们需先精心筹备好以下软件环境。

  1. Luatools 工具；
  2. 内核固件文件（底层 core 固件文件）：LuatOS-SoC_V10001_Air8101.soc；参考项目使用的内核固
  3. luatos 需要的脚本和资源文件

脚本和资源文件：https://gitee.com/openLuat/LuatOS-Air8101/tree/master/demo/TCP

lib 脚本文件：使用 Luatools 烧录时，勾选 添加默认 lib 选项，使用默认 lib 脚本文件；

准备好软件环境之后，接下来查看如何烧录项目文件到 Air8101 开发板，将本篇文章中演示使用的项目文件烧录到 AirAir8101 核心板中。

3.3 合宙 TCP/UDP web 测试工具

为了方便测试，合宙提供了免费的不可商用的 TCP/UDP web 测试工具：合宙 TCP/UDP web 工具 (luatos.com)

详细使用说明参考：合宙 TCP/UDP web 测试工具使用说明 。

3.4 PC 端串口工具

SSCOM 的下载链接：SSCOM ，详细使用说明可以直接参考下载网站。

  • 串口接线方式：Air8101 提供三个 Uart.

MAIN_UART：通用串口，可用于 AT 命令和数据传输 最大波特率 921600bps，默认波特率自适应 9600-115200bps 支持硬件流控（RTS/CTS）

AUX_UART：通用串口

DBG_UART：用于输出调试信息

注意：

  • 以上 PinOut 图示, 对应的 V1.8 的开发板，版本号在板子丝印上可查阅。
  • V1.4 的开发板, 由于 LCD 脚有差异, 图示的 LCD_RS/LCD_CLK 实际位于开发板 管脚编号 06/05 的 UART2/AUX_UART 脚, 不在编号 11/14 脚。
  • V1.8 的开发板 17 脚改为 VBAT.

3.3.1 SSCOM 工具设置：初始配置

3.3.2 数据发送前的配置

四、TCP-UART 透传实现的概述

本小节教你怎么使用 luatos 脚本语言，就可以让合宙 4G 模组连接上一个 TCP 服务器，并且模组和服务器之间实现数据的双向传输！

4.1 本教程实现的功能定义：

  • 通过网页端启动一个 TCP 服务器；
  • 4G 模组插卡开机后，连接上 TCP 服务器；
  • 4G 模组向 TCP 服务器发送 "TCP CONNECT"，服务器可以收到数据并且在网页端显示；
  • TCP 服务器网页端向 4G 模组发送 data from TCP server，4G 模组可以收到数据并且通过串口输出显示；

4.2 文章内容引用

  • Air8101 开发板软硬件资料 ： 等后续文档补充后，在此引用
  • 以上接口函数不做详细介绍，可通过此链接查看具体介绍：socket - 网络接口 - LuatOS 文档

4.3 核心脚本代码详解

4.3.1 串口初始化

本文示例：串口使用 MAIN_UART(uart1)

--初始化  
local uartid = 1 -- 根据实际设备选取不同的uartid
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

4.3.2 数据接收回调：搭建响应桥梁

这里使用 uart.rx 接口，和以 zbuff 的方式存储从 uart1 外部串口收到的数据 -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。。

uart.on(uartid, "receive", function(id, len)
     while true do
-- 接收串口收到的数据，并赋值到uart_rx_buff
        local len = uart.rx(id, uart_rx_buff)  
               if len <= 0 then    -- 接收到的字节长度为0 则退出
                    break
              end
-- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
               if connect_state then
 sys_send(taskName, socket.EVENT, 0)
               end
        end
  end)

4.3.3 TCP 网络配置：铺就数据通道

----------------------------------------------网络配置-------------------------------------------------
local libnet = require "libnet"  -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"         -- 连接TCP服务器的ip地址
local port = 46244               -- 连接TCP服务器的端口
local netCB = nil                  -- socket服务的回调函数
local connect_state = false         -- 连接状态 true:已连接   false:未连接
local protocol = false             -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = false                    -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)  -- 发送至TCP服务器的数据
=======================================================
sys.waitUntil("IP_READY")                -- 等待联网成功
 netCB = socket.create(nil, taskName)     -- 创建socket对象
 socket.debug(netCB, true)                -- 打开调试日志
 socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

4.3.4 TCP 至串口透传：数据无缝流转

succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
  if not succ then
     log.info("服务器断开了", succ, param, ip, port)
     break
 end
  if rx_buff:used() > 0 then
    log.info("收到服务器数据，长度", rx_buff:used())
    uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
    rx_buff:del()
  end

4.3.5 串口至 TCP 反透传：信息双向传递

tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给TCP待发送数据的buff中
uart_rx_buff:del()                      -- 清除串口buff的数据长度
 if tx_buff:used() > 0 then
 log.info("发送到服务器数据，长度", tx_buff:used())
local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
 if not result then
 log.info("发送失败了", result, param)
 break
end
 end
tx_buff:del()

4.4 成果演示与深度解析：视频 + 图文全面展示

4.4.1 成果运行精彩呈现

Air8101 连接 wifi 成功以后 Luatools 会打印已联网，当设备链接到服务器后 会主动给服务器发送 TCP CONNECT，如下图所示。

4.4.2 完整实例深度剖析

-- LuaTools需要PROJECT和VERSION这两个信息
PROJECT = "Wifi_TCP_Uart"
VERSION = "1.0.0"

-- 引入必要的库文件(lua编写), 内部库不需要require
sys = require("sys")
require("sysplus")

_G.sysplus = require("sysplus")
local taskName = "TCP_TASK"             -- sysplus库用到的任务名称，也作为任务id

if wdt then
    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
    wdt.init(9000)--初始化watchdog设置为9s
    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
end
local uartid = 1 -- 根据实际设备选取不同的uartid    
local uart_rx_buff = zbuff.create(1024)     -- 串口接收到的数据
local libnet = require "libnet"         -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"               -- 连接tcp服务器的ip地址
local port = 46646             -- 连接tcp服务器的端口
local netCB = nil                       -- socket服务的回调函数
local connect_state = false             -- 连接状态 true:已连接   false:未连接
local protocol = false                  -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = false                       -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)      -- 发送至tcp服务器的数据
local rx_buff = zbuff.create(1024)      -- 从tcp服务器接收到的数据
local data_buf
--初始化
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

sys.taskInit(function()
    sys.wait(1000)
    -----------------------------
    ---------wifi 联网-----------
    -----------------------------
    if wlan and wlan.connect then
        -- wifi 联网, Air8101系列均支持
        local ssid = "test"
        local password = "waljy2333"
        log.info("wifi", ssid, password)
        wlan.init()
        wlan.setMode(wlan.STATION)
        wlan.connect(ssid, password, 1)
        local result, data = sys.waitUntil("IP_READY")
        log.info("wlan", "IP_READY", result, data)
        device_id = wlan.getMac()
    end
    log.info("已联网")
    sys.publish("net_ready")
end)

function TCP_TASK()
    -- 打印一下连接的目标ip和端口号
    log.info("connect ip: ", ip, "port:", port)

    sys.waitUntil("IP_READY")                -- 等待联网成功
    netCB = socket.create(nil, taskName)     -- 创建socket对象
    socket.debug(netCB, true)                -- 打开调试日志
    socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

    -- 串口和TCP服务器的交互逻辑
    while true do
        -- 连接服务器，返回是否连接成功
        result = libnet.connect(taskName, 15000, netCB, ip, port)

        -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。
        uart.on(uartid, "receive", function(id, len)
            while true do
              local len = uart.rx(id, uart_rx_buff)   -- 接收串口收到的数据，并赋值到uart_rx_buff
               if len <= 0 then    -- 接收到的字节长度为0 则退出
                   break
                end
                -- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
                if connect_state then
                   sys_send(taskName, socket.EVENT, 0)
                end
                break
            end
        end)

        -- 如果连接成功，则改变连接状态参数，并且随便发一条数据到服务器，看服务器能不能收到
        if result then
            connect_state = true
            libnet.tx(taskName, 0, netCB, "TCP  CONNECT")
        end

        -- 连接上服务器后，等待处理接收服务器下行至模块的数据 和 发送串口的数据到服务器
        while result do
            succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
            if not succ then
                log.info("服务器断开了", succ, param, ip, port)
                break
            end

            if rx_buff:used() > 0 then
                log.info("收到服务器数据，长度", rx_buff:used())

                uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
                rx_buff:del()
            end

            tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给tcp待发送数据的buff中
            uart_rx_buff:del()                      -- 清除串口buff的数据长度
            if tx_buff:used() > 0 then
                log.info("发送到服务器数据，长度", tx_buff:used())
                local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
                if not result then
                    log.info("发送失败了", result, param)
                    break
                end
            end
            tx_buff:del()

            -- 如果zbuff对象长度超出，需要重新分配下空间
            if uart_rx_buff:len() > 1024 then
                uart_rx_buff:resize(1024)
            end
            if tx_buff:len() > 1024 then
                tx_buff:resize(1024)
            end
            if rx_buff:len() > 1024 then
                rx_buff:resize(1024)
            end
            log.info(rtos.meminfo("sys"))   -- 打印系统内存

            -- 阻塞等待新的消息到来，比如服务器下发，串口接收到数据
            result, param = libnet.wait(taskName, 15000, netCB)
            if not result then
                log.info("服务器断开了", result, param)
                break
            end
        end

        -- 服务器断开后的行动，由于while true的影响，所以会再次重新执行进行 重新连接。
        connect_state = false
        libnet.close(d1Name, 5000, netCB)
        tx_buff:clear(0)
        rx_buff:clear(0)
        sys.wait(1000)
    end

end

-- libnet库依赖于sysplus，所以只能通过sysplus.taskInitEx创建的任务函数中运行
sysplus.taskInitEx(TCP_TASK, taskName, netCB)

-- 用户代码已结束---------------------------------------------
-- 结尾总是这一句
sys.run()
-- sys.run()之后后面不要加任何语句!!!!!

五、TCP 单向认证

TCP（Transmission Control Protocol，传输控制协议）本身是一种面向连接的、可靠的、基于字节流的传输层通信协议，它并不直接涉及认证过程。然而，在 TCP 连接的基础上，可以实现各种安全机制，其中包括认证。在网络通信中，“单向认证”指的是只对通信某一方的身份合法性进行认证。

本小节教你怎么使用 luatos 脚本语言，就可以让合宙 4G 模组和 TCP 服务器进行单向认证

5.1 本教程实现的功能定义：

  • 通过网页端启动一个 TCP 服务器；
  • 4G 模组插卡开机后，连接上 TCP 服务器；
  • 4G 模组向 TCP 服务器发送 "TCP CONNECT"，服务器可以收到数据并且在网页端显示；
  • TCP 服务器网页端向 4G 模组发送 data from TCP server，4G 模组可以收到数据并且通过串口输出显示；

5.2 文章内容引用

  • Air8101 开发板软硬件资料 ： 等后续文档补充后，在此引用
  • 以上接口函数不做详细介绍，可通过此链接查看具体介绍：socket - 网络接口 - LuatOS 文档

5.3 核心脚本代码详解

5.3.1 串口初始化

本文示例：串口使用 MAIN_UART(uart1)

--初始化  
local uartid = 1 -- 根据实际设备选取不同的uartid
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

5.3.2 数据接收回调：搭建响应桥梁

这里使用 uart.rx 接口，和以 zbuff 的方式存储从 uart1 外部串口收到的数据 -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。

uart.on(uartid, "receive", function(id, len)
     while true do
-- 接收串口收到的数据，并赋值到uart_rx_buff
        local len = uart.rx(id, uart_rx_buff)  
               if len <= 0 then    -- 接收到的字节长度为0 则退出
                    break
              end
-- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
               if connect_state then
 sys_send(taskName, socket.EVENT, 0)
               end
        end
  end)

5.3.3 TCP 网络配置：铺就数据通道--------注：SSL 填写 true

----------------------------------------------网络配置-------------------------------------------------
local libnet = require "libnet"  -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"         -- 连接TCP服务器的ip地址
local port = 46244               -- 连接TCP服务器的端口
local netCB = nil                  -- socket服务的回调函数
local connect_state = false         -- 连接状态 true:已连接   false:未连接
local protocol = false             -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = true**   **             -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)  -- 发送至TCP服务器的数据
=======================================================
sys.waitUntil("IP_READY")                -- 等待联网成功
 netCB = socket.create(nil, taskName)     -- 创建socket对象
 socket.debug(netCB, true)                -- 打开调试日志
 socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

5.3.4 TCP 至串口透传：数据无缝流转

succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
  if not succ then
     log.info("服务器断开了", succ, param, ip, port)
     break
 end
  if rx_buff:used() > 0 then
    log.info("收到服务器数据，长度", rx_buff:used())
    uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
    rx_buff:del()
  end

5.3.5 串口至 TCP 反透传：信息双向传递

tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给TCP待发送数据的buff中
uart_rx_buff:del()                      -- 清除串口buff的数据长度
 if tx_buff:used() > 0 then
 log.info("发送到服务器数据，长度", tx_buff:used())
local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
 if not result then
 log.info("发送失败了", result, param)
 break
end
 end
tx_buff:del()

5.4 成果演示与深度解析：视频 + 图文全面展示

5.4.1 成果运行精彩呈现

TCP SSL 进行单向认证测试，测试服务器和 sscom 交互，如下图所示，测试正常。

5.4.3 完整实例深度剖析

-- main.lua文件

-- LuaTools需要PROJECT和VERSION这两个信息
PROJECT = "Wifi_TCP_Uart"
VERSION = "1.0.0"

log.info("main", PROJECT, VERSION)

-- 引入必要的库文件(lua编写), 内部库不需要require
sys = require("sys")

_G.sysplus = require("sysplus")
local taskName = "TCP_TASK"             -- sysplus库用到的任务名称，也作为任务id

if wdt then
    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
    wdt.init(9000)--初始化watchdog设置为9s
    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
end

local uartid = 1 -- 根据实际设备选取不同的uartid
local uart_rx_buff = zbuff.create(1024)     -- 串口接收到的数据

local libnet = require "libnet"         -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"               -- 连接tcp服务器的ip地址
local port = 46697            -- 连接tcp服务器的端口
local netCB = nil                       -- socket服务的回调函数
local connect_state = false             -- 连接状态 true:已连接   false:未连接
local protocol = false                  -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = true                     -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)      -- 发送至tcp服务器的数据
local rx_buff = zbuff.create(1024)      -- 从tcp服务器接收到的数据

--初始化
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

sys.taskInit(function()
    sys.wait(1000)
    -----------------------------
    ---------wifi 联网-----------
    -----------------------------
if wlan and wlan.connect then
        -- wifi 联网, Air8101系列均支持
        local ssid = "test"
        local password = "waljy2333"
        log.info("wifi", ssid, password)
        wlan.init()
        wlan.setMode(wlan.STATION)
        wlan.connect(ssid, password, 1)
        local result, data = sys.waitUntil("IP_READY")
        log.info("wlan", "IP_READY", result, data)
        device_id = wlan.getMac()
    end
    log.info("已联网")
    sys.publish("net_ready")
end)

function TCP_TASK()
    -- 打印一下连接的目标ip和端口号
    log.info("connect ip: ", ip, "port:", port)

    sys.waitUntil("IP_READY")                -- 等待联网成功
    netCB = socket.create(nil, taskName)     -- 创建socket对象
    socket.debug(netCB, true)                -- 打开调试日志
    socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

    -- 串口和TCP服务器的交互逻辑
    while true do
        -- 连接服务器，返回是否连接成功
        result = libnet.connect(taskName, 15000, netCB, ip, port)

        -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。
        uart.on(uartid, "receive", function(id, len)
            while true do
                local len = uart.rx(id, uart_rx_buff)   -- 接收串口收到的数据，并赋值到uart_rx_buff
                if len <= 0 then    -- 接收到的字节长度为0 则退出
                    break
                end
                -- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
                if connect_state then
                    sys_send(taskName, socket.EVENT, 0)
                end
            end
        end)

        -- 如果连接成功，则改变连接状态参数，并且随便发一条数据到服务器，看服务器能不能收到
        if result then
            connect_state = true
            libnet.tx(taskName, 0, netCB, "TCP  CONNECT")
        end

        -- 连接上服务器后，等待处理接收服务器下行至模块的数据 和 发送串口的数据到服务器
        while result do
            succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
            if not succ then
                log.info("服务器断开了", succ, param, ip, port)
                break
            end

            if rx_buff:used() > 0 then
                log.info("收到服务器数据，长度", rx_buff:used())

                uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
                rx_buff:del()
            end

            tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给tcp待发送数据的buff中
            uart_rx_buff:del()                      -- 清除串口buff的数据长度
            if tx_buff:used() > 0 then
                log.info("发送到服务器数据，长度", tx_buff:used())
                local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
                if not result then
                    log.info("发送失败了", result, param)
                    break
                end
            end
            tx_buff:del()

            -- 如果zbuff对象长度超出，需要重新分配下空间
            if uart_rx_buff:len() > 1024 then
                uart_rx_buff:resize(1024)
            end
            if tx_buff:len() > 1024 then
                tx_buff:resize(1024)
            end
            if rx_buff:len() > 1024 then
                rx_buff:resize(1024)
            end
            log.info(rtos.meminfo("sys"))   -- 打印系统内存

            -- 阻塞等待新的消息到来，比如服务器下发，串口接收到数据
            result, param = libnet.wait(taskName, 15000, netCB)
            if not result then
                log.info("服务器断开了", result, param)
                break
            end
        end

        -- 服务器断开后的行动，由于while true的影响，所以会再次重新执行进行 重新连接。
        connect_state = false
        libnet.close(d1Name, 5000, netCB)
        tx_buff:clear(0)
        rx_buff:clear(0)
        sys.wait(1000)
    end

end

-- libnet库依赖于sysplus，所以只能通过sysplus.taskInitEx创建的任务函数中运行
sysplus.taskInitEx(TCP_TASK, taskName, netCB)

-- 用户代码已结束---------------------------------------------
-- 结尾总是这一句
sys.run()
-- sys.run()之后后面不要加任何语句!!!!!

六、TCP 双向认证

（待更新）

七、TCP 断链续连

TCP（传输控制协议）确保数据在网络中可靠传输。当 TCP 连接因网络问题、设备故障等原因断开时，需要重新建立连接以继续数据传输。

7.1 本教程实现的功能定义：

断链：TCP 连接断开，可能由于网络不稳定、设备故障等。

续连：重新建立 TCP 连接。通常通过“三次握手”过程：

  • 客户端请求连接。
  • 服务器响应并同意连接。
  • 客户端确认连接建立。

7.2 文章内容引用

  • Air8101 开发板软硬件资料 ：等后续文档补充后，在此引用
  • 以上接口函数不做详细介绍，可通过此链接查看具体介绍：socket - 网络接口 - LuatOS 文档

7.3 核心脚本代码详解

7.3.1 串口初始化

本文示例：串口使用 MAIN_UART(uart1)

--初始化  
local uartid = 1 -- 根据实际设备选取不同的uartid
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

7.3.2 数据接收回调：搭建响应桥梁

这里使用 uart.rx 接口，和以 zbuff 的方式存储从 uart1 外部串口收到的数据 -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。

uart.on(uartid, "receive", function(id, len)
     while true do
        -- 接收串口收到的数据，并赋值到uart_rx_buff
        local len = uart.rx(id, uart_rx_buff)  
        if len <= 0 then    -- 接收到的字节长度为0 则退出
            break
        end
        -- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
        if connect_state then
            sys_send(taskName, socket.EVENT, 0)
        end
     end
  end)

7.3.3 TCP 网络配置：铺就数据通道--------注：需要认证 SSL 填写：true，不需要 填写： false。

----------------------------------------------网络配置-------------------------------------------------
local libnet = require "libnet"  -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"         -- 连接TCP服务器的ip地址
local port = 46244               -- 连接TCP服务器的端口
local netCB = nil                  -- socket服务的回调函数
local connect_state = false         -- 连接状态 true:已连接   false:未连接
local protocol = false             -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = true** **                -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)  -- 发送至TCP服务器的数据
=======================================================
sys.waitUntil("IP_READY")                -- 等待联网成功
 netCB = socket.create(nil, taskName)     -- 创建socket对象
 socket.debug(netCB, true)                -- 打开调试日志
 socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

7.3.4 TCP 至串口透传：数据无缝流转

succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
  if not succ then
     log.info("服务器断开了", succ, param, ip, port)
     break
 end
  if rx_buff:used() > 0 then
    log.info("收到服务器数据，长度", rx_buff:used())
    uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
    rx_buff:del()
  end

7.3.5 串口至 TCP 反透传：信息双向传递

tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给TCP待发送数据的buff中
uart_rx_buff:del()                      -- 清除串口buff的数据长度
 if tx_buff:used() > 0 then
 log.info("发送到服务器数据，长度", tx_buff:used())
local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
 if not result then
 log.info("发送失败了", result, param)
 break
end
 end
tx_buff:del()

7.3.6 断链续连

while true do
        -- 连接服务器，返回是否连接成功
        result = libnet.connect(taskName, 15000, netCB, ip, port)
        -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。
        uart.on(uartid, "receive", function(id, len)
            while true do
                local len = uart.rx(id, uart_rx_buff)   -- 接收串口收到的数据，并赋值到uart_rx_buff
                if len <= 0 then    -- 接收到的字节长度为0 则退出
                    break
                end
                -- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
                if connect_state then
                    sys_send(taskName, socket.EVENT, 0)
                end
            end
        end)
        -- 如果连接成功，则改变连接状态参数，并且随便发一条数据到服务器，看服务器能不能收到
        if result then
            connect_state = true
            libnet.tx(taskName, 0, netCB, "TCP  CONNECT")
        end
        -- 连接上服务器后，等待处理接收服务器下行至模块的数据 和 发送串口的数据到服务器
        while result do
            succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
            if not succ then
                log.info("服务器断开了", succ, param, ip, port)
                break
            end
            if rx_buff:used() > 0 then
                log.info("收到服务器数据，长度", rx_buff:used())

                uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
                rx_buff:del()
            end

            tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给tcp待发送数据的buff中
            uart_rx_buff:del()                      -- 清除串口buff的数据长度
            if tx_buff:used() > 0 then
                log.info("发送到服务器数据，长度", tx_buff:used())
                local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
                if not result then
                    log.info("发送失败了", result, param)
                    break
                end
            end
            tx_buff:del()
            -- 如果zbuff对象长度超出，需要重新分配下空间
            if uart_rx_buff:len() > 1024 then
                uart_rx_buff:resize(1024)
            end
            if tx_buff:len() > 1024 then
                tx_buff:resize(1024)
            end
            if rx_buff:len() > 1024 then
                rx_buff:resize(1024)
            end
            log.info(rtos.meminfo("sys"))   -- 打印系统内存
            -- 阻塞等待新的消息到来，比如服务器下发，串口接收到数据
            result, param = libnet.wait(taskName, 15000, netCB)
            if not result then
                log.info("服务器断开了", result, param)
                break
            end
        end
  -- 服务器断开后的行动，由于while true的影响，所以会再次重新执行进行 重新连接。

7.4 成果演示与深度解析：视频 + 图文全

7.4.1 成果运行精彩呈现

断掉服务器，然后查看是否重新连接（重新连接正常）,如下图所示。

断掉 wifi，然后查看是否重新连接（重新连接正常），如下图所示。

7.4.2 完整实例深度剖析

-- main.lua文件

-- LuaTools需要PROJECT和VERSION这两个信息
PROJECT = "Wifi_TCP_Uart"
VERSION = "1.0.0"

log.info("main", PROJECT, VERSION)

-- 引入必要的库文件(lua编写), 内部库不需要require
sys = require("sys")

_G.sysplus = require("sysplus")
local taskName = "TCP_TASK"             -- sysplus库用到的任务名称，也作为任务id

if wdt then
    --添加硬狗防止程序卡死，在支持的设备上启用这个功能
    wdt.init(9000)--初始化watchdog设置为9s
    sys.timerLoopStart(wdt.feed, 3000)--3s喂一次狗
end

local uartid = 1 -- 根据实际设备选取不同的uartid
local uart_rx_buff = zbuff.create(1024)     -- 串口接收到的数据

local libnet = require "libnet"         -- libnet库，支持tcp、udp协议所用的同步阻塞接口
local ip = "112.125.89.8"               -- 连接tcp服务器的ip地址
local port = 43115                -- 连接tcp服务器的端口
local netCB = nil                       -- socket服务的回调函数
local connect_state = false             -- 连接状态 true:已连接   false:未连接
local protocol = false                  -- 通讯协议 true:UDP协议  false:TCP协议
local ssl = false                       -- 加密传输 true:加密     false:不加密
local tx_buff = zbuff.create(1024)      -- 发送至tcp服务器的数据
local rx_buff = zbuff.create(1024)      -- 从tcp服务器接收到的数据

--初始化
uart.setup(
    uartid,--串口id
    115200,--波特率
    8,--数据位
    1--停止位
)

sys.taskInit(function()
    sys.wait(1000)
    -----------------------------
    ---------wifi 联网-----------
    -----------------------------
    if wlan and wlan.connect then
        -- wifi 联网, Air8101系列均支持
        local ssid = "test"                 --wifi 名
        local password = "waljy2333"        --wifi 密码
        log.info("wifi", ssid, password)
        wlan.init()
        wlan.setMode(wlan.STATION)
        wlan.connect(ssid, password, 1)
        local result, data = sys.waitUntil("IP_READY")
        log.info("wlan", "IP_READY", result, data)
        device_id = wlan.getMac()
    end
    log.info("已联网")
    sys.publish("net_ready")
end)

function TCP_TASK()
    -- 打印一下连接的目标ip和端口号
    log.info("connect ip: ", ip, "port:", port)

    sys.waitUntil("IP_READY")                -- 等待联网成功
    netCB = socket.create(nil, taskName)     -- 创建socket对象
    socket.debug(netCB, true)                -- 打开调试日志
    socket.config(netCB, nil, protocol, ssl)      -- 此配置为TCP连接，无SSL加密

    -- 串口和TCP服务器的交互逻辑
    while true do
        -- 连接服务器，返回是否连接成功
        result = libnet.connect(taskName, 15000, netCB, ip, port)

        -- 收取数据会触发回调, 这里的"receive" 是固定值不要修改。
        uart.on(uartid, "receive", function(id, len)
            while true do
                local len = uart.rx(id, uart_rx_buff)   -- 接收串口收到的数据，并赋值到uart_rx_buff
                if len <= 0 then    -- 接收到的字节长度为0 则退出
                    break
                end
                -- 如果已经在线了，则发送socket.EVENT消息来打断任务里的阻塞等待状态，让任务循环继续
                if connect_state then
                    sys_send(taskName, socket.EVENT, 0)
                end
            end
        end)

        -- 如果连接成功，则改变连接状态参数，并且随便发一条数据到服务器，看服务器能不能收到
        if result then
            connect_state = true
            libnet.tx(taskName, 0, netCB, "TCP  CONNECT")
        end

        -- 连接上服务器后，等待处理接收服务器下行至模块的数据 和 发送串口的数据到服务器
        while result do
            succ, param, _, _ = socket.rx(netCB, rx_buff)   -- 接收数据
            if not succ then
                log.info("服务器断开了", succ, param, ip, port)
                break
            end

            if rx_buff:used() > 0 then
                log.info("收到服务器数据，长度", rx_buff:used())

                uart.tx(uartid, rx_buff)    -- 从服务器收到的数据转发 从串口输出
                rx_buff:del()
            end

            tx_buff:copy(nil, uart_rx_buff)         -- 将串口数据赋值给tcp待发送数据的buff中
            uart_rx_buff:del()                      -- 清除串口buff的数据长度
            if tx_buff:used() > 0 then
                log.info("发送到服务器数据，长度", tx_buff:used())
                local result = libnet.tx(taskName, 0, netCB, tx_buff)   -- 发送数据
                if not result then
                    log.info("发送失败了", result, param)
                    break
                end
            end
            tx_buff:del()

            -- 如果zbuff对象长度超出，需要重新分配下空间
            if uart_rx_buff:len() > 1024 then
                uart_rx_buff:resize(1024)
            end
            if tx_buff:len() > 1024 then
                tx_buff:resize(1024)
            end
            if rx_buff:len() > 1024 then
                rx_buff:resize(1024)
            end
            log.info(rtos.meminfo("sys"))   -- 打印系统内存

            -- 阻塞等待新的消息到来，比如服务器下发，串口接收到数据
            result, param = libnet.wait(taskName, 15000, netCB)
            if not result then
                log.info("服务器断开了", result, param)
                break
            end
        end

        -- 服务器断开后的行动，由于while true的影响，所以会再次重新执行进行 重新连接。
        connect_state = false
        libnet.close(d1Name, 5000, netCB)
        tx_buff:clear(0)
        rx_buff:clear(0)
        sys.wait(1000)
    end

end

-- libnet库依赖于sysplus，所以只能通过sysplus.taskInitEx创建的任务函数中运行
sysplus.taskInitEx(TCP_TASK, taskName, netCB)

-- 用户代码已结束---------------------------------------------
-- 结尾总是这一句
sys.run()
-- sys.run()之后后面不要加任何语句!!!!!

八、TCP 低功耗唤醒

（待更新）

九、总结

TCP（传输控制协议）和 UDP（用户数据报协议）是 OSI 模型中运输层的两种协议。TCP 是面向连接的可靠传输协议，通过复杂的拥塞控制和重传机制确保数据无差错、不丢失、不重复且有序地到达；而 UDP 则是无连接的不可靠传输协议，它尽最大努力交付数据，不保证数据的可靠性，但具有较好的实时性和较高的工作效率，适用于对高速传输和实时性要求较高的通信场景。

十、常见问题

10.1 sys.waitUntil("IP_READY") -- 等待联网成功

好多新入手的可能看到此函数 不理解 在整个脚本里面没有发布此事件 sys.publish（"IP_READY"） 为什么 后面还联网成功了？

此处解释一下 模组上电以后固件内部联网成功以后会自动发布 sys.publish（"IP_READY")。

10.2 使用路由器提供网络链接，出现断链情况

如果使用 NAT 那么在端口映射只的表内有一个超时时间而这个超时时间各个路由器的出厂设置不一样，有 1 天，有 1 分钟，有两小时等等。而我们长连接在没有消息的时候，服务器会定时的发送心跳包来检测，但设定的时间是 5 分钟，或者就会影响链接，不同路由器时间不通讯掉链接的时间不一样。如下图是出现的现象。

注：目前使用手机卡提供 WiFi 未出现如上情况。

十一、扩展

11.1 TCP 单向认证

  • 定义：单向认证是指在通信过程中，只有一方（通常是服务器）对另一方（通常是客户端）进行身份验证。
  • 应用：在 TCP 连接中，单向认证常用于客户端向服务器发起请求时，服务器验证客户端的身份。
  • 特点：实现简单，但安全性相对较低，因为只验证了一方的身份。

11.2 TCP 双向认证

  • 定义：双向认证是指通信双方都需要对对方进行身份验证，只有双方都通过对方的认证请求时，通信才会被允许。
  • 应用：在需要高安全性的场景中，如金融服务、医疗信息传输等，TCP 双向认证被广泛应用。
  • 特点：安全性高，但实现复杂，且可能带来一定的性能开销。