Smart Ports，一个跑脚本的自动化多端口（串口，TCP，TCP服务器，UDP）通信工具，功能非常强大且好用

Hippop

链接: https://pan.baidu.com/s/1xmMDZDvasJvV-0Vs1oF2rA 提取码: hi9a

说说特点：
1、UI美观漂亮
2、使用LUA语言实时编程控制串口，网络端口进行数据收发，解析，自动化处理，复杂交互处理，多端口同时工作
3、执行程序可随时停止、暂停、恢复
4、支持GUI以及脚本程序管理端口创建，配置修改，连接断开，端口移除等
5、多任务高并发处理，可同时处理几千至上万的端口，本地串口数量支持任意多个
6、完全支持易用强大的LUA原生库（支持字符串和文件处理），借助LUA自带的string库，可拥有字符串正则处理拆分匹配，数据拆包解包等。
7、工具提供40多个相关的API，可非常方便的实现端口管理，配置，数据收发，事件监听，多任务，电脑串口列表枚举，拔插监听等等
8、采用多任务阻塞式编程，更加易用，便捷
9、串口支持，流控线单独控制，任意波特率以及其他的配置，流控支持RTS/CTS, DTR/DSR, XON/XOFF，可设置XON/XOFF流控字符。
10、支持创建表格，数据实时展示，更新
11、接口尽量简单，功能正交
12、可实现你想的或者想不到的功能
13、自带一个词法高亮的脚本编辑器，代码看起来很爽
14、支持Windows XP及以上

以下是程序截图：
主界面及说明：


运行效果图1：

运行效果图2:

运行效果图3:


使用这个工具你可以：
1、做端口双向透传，并抓取中间的数据
2、搭建一个服务器
3、远程操控单片机
4、自动化测试，自动控制等等
5、集中化管理多台设备，多设备自动化控制控制中心

最后：本工具没有任何病毒，杀毒软件报毒请通过。为了实现单文件无依赖绿色程序，我将动态库集成到了程序本体中，并动态加载，这个行为比较容易被杀毒软件误报。

Hippop

本工具属于首发，目前网上不存在也找不到对应的下载，之后可能会在其他的地方发布。

Hippop

示例：UDP发送器

1. 
   
2. --构造一个65507的数据
   
3. big_data = string.rep("1", 65507)
   
4. --测试端口名
   
5. test = "test"
   
6. 
   
7. --移除同名端口
   
8. portRemove(test)
   
9. --创建UDP端口并打开
   
10. portCreate(test, "Udp", {port_num = 4000})
    
11. portConnect(test)
    
12. 
    
13. --压力发送数据
    
14. function sendTask(port)
    
15.     --记录上次时间和数据量
    
16.     local len = 0
    
17.     local lastTime = gettime()
    
18. 
    
19.     while true do
    
20.         --发送数据
    
21.         local sbytes, err = portSend(port, "127.0.0.1:2000", big_data)
    
22. 
    
23.         --失败处理
    
24.         if err ~= 0 then
    
25.             print("发送失败!")
    
26.             return
    
27.         end
    
28. 
    
29.         --发送数据量统计
    
30.         len = len + sbytes
    
31. 
    
32.         --超过300M做一次速率统计
    
33.         if len > 300 * 1024 * 1024  then
    
34.             --获取当前时间
    
35.             local cur = gettime()
    
36. 
    
37.             --计算间隔
    
38.             local spec = cur - lastTime
    
39.             lastTime = cur
    
40. 
    
41.             --打印速率
    
42.             printf(port..": 当前速率为:%.2f KB/S\n", len * 1000 / 1024 / spec)
    
43.             len = 0
    
44.         end
    
45.     end
    
46. end
    
47. 
    
48. --创建发送任务
    
49. taskStart(sendTask, test)
    

复制代码

UDP接收器：

1. 
   
2. test = "test"
   
3. 
   
4. --创建名为test的UDP端口，为确保创建成功，先尝试移除同名端口
   
5. portRemove(test)
   
6. portCreate(test, "Udp", {port_num = 2000})
   
7. --打开这个端口
   
8. portConnect(test)
   
9. 
   
10. --接收任务
    
11. function recvTask(port)
    
12.     --记录时间和数据量
    
13.     local len = 0
    
14.     local lastTime = gettime()
    
15. 
    
16.     while true do
    
17.         --接收端口发来的数据
    
18.         local data, err, ip = portRecv(port)
    
19.         --错误处理
    
20.         if err ~= 0 then
    
21.             print("接收错误:"..err)
    
22.             return
    
23.         end
    
24. 
    
25.         --统计数据量
    
26.         len = len + #data
    
27. 
    
28.         --超过300M打印一下速率
    
29.         if len > 300 * 1024 * 1024  then
    
30.             --获取当前时间，精确到ms
    
31.             local cur = gettime()
    
32. 
    
33.             --计算间隔
    
34.             local spec = cur - lastTime
    
35.             lastTime = cur
    
36. 
    
37.             --打印速率
    
38.             printf(port..": 当前速率为:%.2f KB/S\n", len * 1000 / 1024 / spec)
    
39.             len = 0
    
40.         end
    
41.     end
    
42. end
    
43. 
    
44. --启动接收任务
    
45. taskStart(recvTask, "test")
    

复制代码

串口自动监听：
当串口插入电脑后，创建任务自动监听其数据并存入文件，串口拔出后，进入等待，串口再次插入后自动连接，并继续接收数据

1. 
   
2. --串口配置
   
3. config = {
   
4.     baudrate = 115200,  --115200波特率
   
5.     dataBits = 8,            --8位数据位
   
6.     stopBits = 1,            --1位停止位，当使用1.5时请使用字符串"1.5"
   
7.     parity = "N",            --无校验
   
8.     flowctl = 0               --无流控
   
9. }
   
10. 
    
11. --获取已连接的端口列表
    
12. local connList = portConnectedListGet()
    
13. 
    
14. --遍历当前已连接的端口，断开其中的串口端口
    
15. for k, v in pairs(connList) do
    
16.     --断开类型为串口的端口
    
17.     if portInfo(k).type == "Serial" then
    
18.         portRemove(k)
    
19.     end
    
20. end
    
21. 
    
22. --串口数据接收任务
    
23. function recvTask(port)
    
24.     --记录数据到文件中
    
25.     local dataRecordFile = io.open(port.."_RECORD", "wb")
    
26.     if dataRecordFile == nil then
    
27.         --文件打开失败
    
28.         printf("文件%s打开失败，无法记录当前串口的数据！\n", port.."RECORD")
    
29.     end
    
30. 
    
31.     --不停的接收来自串口的任务
    
32.     while true do
    
33.         local data, err = portRecv(port)
    
34. 
    
35.         --发生错误
    
36.         if err ~= 0 then
    
37.             while true do
    
38.                 --等待端口连接
    
39.                 local info = portInfo(port)
    
40. 
    
41.                 --被销毁
    
42.                 if info.state == "destroyed" then
    
43.                     print(port..": 已销毁！")
    
44.                     dataRecordFile:close()
    
45.                     return
    
46.                 --已连接上
    
47.                 elseif info.state == "connected" then
    
48.                     print(port..": 已连接！")
    
49.                     break
    
50.                 end
    
51. 
    
52.                 --等待状态变化
    
53.                 portEventWait(port)
    
54.             end
    
55.         else
    
56.             --记录数据
    
57.             dataRecordFile:write(data)
    
58.             --打印数据
    
59.             print(port..":"..data)
    
60.         end
    
61.     end
    
62. end
    
63. 
    
64. --为当前插上的串口创建接收任务
    
65. while true do
    
66.     --获取串口列表
    
67.     local serialList = serialListGet()
    
68. 
    
69.     --创建名为端口号的端口
    
70.     for k, v in pairs(serialList) do
    
71.         --获取将要创建的端口的信息
    
72.         local info = portInfo(k)
    
73. 
    
74.         --这个端口没有创建
    
75.         if info.state == "destroyed" or info.type ~= "Serial" then
    
76.             --尝试移除这个端口
    
77.             portRemove(k)
    
78. 
    
79.             --创建这个串口
    
80.             config.port = k
    
81.             portCreate(k, "Serial", config)
    
82.             --连接这个端口
    
83.             portConnect(k)
    
84.             --创建接收任务
    
85.             taskStart(recvTask, k)
    
86. 
    
87.         --连接断开的端口
    
88.         elseif info.state == "disconnected" then
    
89.             portConnect(k)
    
90.         end
    
91.     end
    
92. 
    
93.     --等待串口列表改变
    
94.     serialListChangedWait()
    
95.     --WinXP需要延时一下才能操作
    
96.     sleep(200)
    
97. end
    

复制代码

TCP回显服务器：
客户端连接上后，发送的所有数据将回显至客户端，支持任意多个客户端

1. 
   
2. --服务器名称
   
3. server = "test"
   
4. 
   
5. --创建TCP服务器，并打开
   
6. portRemove(server)
   
7. portCreate(server, "TcpServer", {port_num = 4000})
   
8. portConnect(server)
   
9. 
   
10. --TCP客户端回显任务
    
11. function client_echo_task(client)
    
12.     --print(client.."已连接！")
    
13.     while true do
    
14.         --等待客户端发送数据
    
15.         local data, err = portRecv(client)
    
16.         --回显
    
17.         if err == 0 then
    
18.             portSend(client, data)
    
19.             --print(client..":"..data)
    
20.         else
    
21.             --print(client.."读出错："..err)
    
22.             break
    
23.         end
    
24.     end
    
25. end
    
26. 
    
27. while true do
    
28.     --等待客户端接入
    
29.     local client, err = portRecv(server)
    
30. 
    
31.     if err == 0 then
    
32.         --创建回显任务
    
33.         taskStart(client_echo_task, client)
    
34.     else
    
35.         print(server.."服务器错误："..err)
    
36.         break
    
37.     end
    
38. end
    

复制代码

TCP客户端：

1. 
   
2. --测试客户端
   
3. client = "test"
   
4. 
   
5. --创建端口，并连接服务器
   
6. portRemove(client)
   
7. portCreate(client, "TcpClient", {host = "localhost", port_num = 4000})
   
8. portConnect(client)
   
9. 
   
10. --接收服务器数据任务
    
11. function recvTask(port)
    
12.     while true do
    
13.         local data, err = portRecv(port)
    
14. 
    
15.         if err ~= 0 then
    
16.             print("客户端接收出错！")
    
17.             exit()
    
18.             return
    
19.         end
    
20. 
    
21.         print(data)
    
22.     end
    
23. end
    
24. 
    
25. --启动接收任务
    
26. taskStart(recvTask, client)
    
27. 
    
28. while true do
    
29.     --每隔1s发送一包数据
    
30.     portSend(client, "Hello..")
    
31.     sleep(1000)
    
32. end
    

复制代码

每个1s自动向服务器发送 "Hello .."

更多示例代码请见分享