通过TCP触发流程与写入全局变量

# 视觉坐标指令解析器

## 概述
本Lua脚本用于解析和处理视觉系统中的坐标指令，支持三种指令格式：

1. **触发类指令** - 触发指定的流程执行
2. **索引坐标指令** - 通过索引映射写入全局变量
3. **命名坐标指令** - 通过名称映射写入全局变量

## 功能特性

### 1. 触发指令处理
- 格式：`$指令名称`
- 示例：`$料仓1上相机标定`
- 作用：根据映射表触发对应的流程

### 2. 索引坐标指令处理
- 格式：`blockIndex,varIndex/x,y,r`
- 示例：`$1,1/100.0,200.0,0.0`
- 作用：将坐标值写入指定的全局变量

### 3. 命名坐标指令处理
- 格式：`坐标名称,x,y,r`
- 示例：`坐标1,100.0,200.0,0.0`
- 作用：通过坐标名称映射写入全局变量

## 配置文件结构

### 1. 触发指令映射表 (TRIGGER_CONFIG)
```lua
local TRIGGER_CONFIG = {
    ["$指令名称"] = "触发的流程名称",
    -- 示例
    ["$料仓1上相机标定"] = "料仓1上相机标定",
}
```

### 2. 全局变量索引映射表 (GLOBAL_VAR_MAPPING)
```lua
local GLOBAL_VAR_MAPPING = {
    -- 格式: "索引键" = {blockName = "全局变量块名", varName = "变量名"}
    ["1,1"] = {blockName = "标定坐标", varName = "料仓1上相机标定"},
}
```

### 3. 命名坐标映射表 (COORDINATE_CONFIG)
```lua
local COORDINATE_CONFIG = {
    -- 格式: 坐标名称 = {blockName = "全局变量块名", varName = "变量名"}
    ["坐标名称"] = {blockName = "全局变量块名", varName = "变量名"},
}
```

## 使用示例

### 触发流程
```
输入: $料仓1上相机标定
输出: 触发名为"料仓1上相机标定"的流程
```

### 写入坐标数据
```
输入: 1,1/100.0,200.0,0.0
输出: 将坐标(100.0, 200.0, 0.0)写入全局变量块"标定坐标"中的"料仓1上相机标定"变量
```

## 函数说明

### 主函数
- `main()`: 主处理函数，读取输入并分发到对应的处理函数

### 处理函数
1. `processSimpleTrigger(command)`: 处理触发指令
2. `processIndexedCoordinate(command)`: 处理索引坐标指令
3. `processSimpleCoordinate(command)`: 处理命名坐标指令

### 写入函数
1. `writeToGlobal_idx(blockIndex, varIndex, value)`: 通过索引写入全局变量
2. `writeToGlobal(blockName, varName, value)`: 通过名称写入全局变量
3. `triggerLineByName(lineName)`: 触发指定名称的流程

## 系统要求
- 支持Lua脚本运行的环境
- 需要以下Lua库支持：
  - `LuaLog`: 日志记录
  - `LuaString`: 字符串处理
  - `LuaSystem`: 系统功能调用
  - `LuaGlobalVar`: 全局变量操作
- `cyPosture`: 姿态对象创建函数

## 错误处理
- 输入为空时记录警告日志
- 无法识别的指令格式时记录错误日志
- 全局变量映射不存在时记录错误日志
- 坐标格式错误时记录错误日志

## 扩展说明

### 1. 添加新的触发指令
在`TRIGGER_CONFIG`表中添加新的键值对：
```lua
["$新指令名称"] = "对应的流程名称"
```

### 2. 添加新的坐标映射
在`GLOBAL_VAR_MAPPING`表中添加新的映射：
```lua
["索引键"] = {blockName = "全局变量块名", varName = "变量名"}
```

### 3. 调试模式
通过设置`debug = true`启用测试模式：
```lua
local debug = true
local testCmd = "1,1/100.3,200.4,10.1"
```

## 注意事项
1. 指令名称需要以`$`开头
2. 坐标值使用逗号分隔的三个浮点数
3. 索引键的格式为"blockIndex,varIndex"
4. 所有映射关系需要在配置表中预先定义
5. 确保Lua库函数正确加载

## 作者
视觉系统开发团队

## 版本历史
- v1.0.0: 初始版本
- 支持三种指令格式解析
- 提供详细的日志记录
- 可扩展的配置结构

## Lua脚本代码
```lua
--输入端口：IN1        字符串
--[[************  上方为输入输出口定义，请勿删除  ************************]]

-- ==================== 配置区域 ====================
-- 在这里配置指令到操作的映射关系
-- 
-- 触发类指令映射表
-- 格式: [指令名称] = "触发的流程名称"
--示例: 发送指令【$料仓1上相机标定】触发映射表中对应的流程
local TRIGGER_CONFIG = {
    -- 当收到"启动流程"的指令时，触发"启动流程"
    -- 可以添加更多触发配置
    --===========标定流程====================
    ["$料仓1上相机标定"] = "料仓1上相机标定",
    ["$料仓2上相机标定"] = "料仓2上相机标定",
    ["$料仓3上相机标定"] = "料仓3上相机标定",
    ["$吸头1标定放置"] = "吸头1标定放置",
    ["$吸头2下相机标定"] = "吸头2下相机标定",
    ["$吸头3下相机标定"] = "吸头3下相机标定",
    ["$吸头4下相机标定"] = "吸头4下相机标定",
    --============映射流程=================== 
    ["$吸头1映射下相机"] = "吸头1映射下相机",
    ["$吸头1映射上相机"] = "吸头1映射上相机",
    ["$吸头2映射下相机"] = "吸头2映射下相机",
    ["$吸头2映射上相机"] = "吸头2映射上相机",
    ["$吸头3映射下相机"] = "吸头3映射下相机",
    ["$吸头3映射上相机"] = "吸头3映射上相机",
    ["$吸头4映射下相机"] = "吸头4映射下相机",
    ["$吸头4映射上相机"] = "吸头4映射上相机",
    --============取料引导流程=================== 
    ["$料仓1取料引导"] = "料仓1取料引导",
    ["$料仓2取料引导"] = "料仓2取料引导",
    ["$料仓3取料引导"] = "料仓3取料引导",
    --============拍镜片下相机流程===================   
    ["$拍镜片下相机1"] = "拍镜片下相机1",
    ["$拍镜片下相机2"] = "拍镜片下相机2",
    ["$拍镜片下相机3"] = "拍镜片下相机3",
    ["$拍镜片下相机4"] = "拍镜片下相机4",
    --============贴装前后检查===================
    ["$贴前检测1"] = "贴前检测1",
    ["$贴前检测2"] = "贴前检测2",
    ["$贴完复检"] = "贴完复检",

}

-- 全局变量索引映射表
---带全局变量索引前缀的坐标类指令配置
-- 格式: {blockIndex, varIndex} = {blockName = "全局变量块名", varName = "变量名"}
--示例： 发送指令：  【1,1/0.0.0,0.0.0,0.0.0"】 将收到到的索引在映射表中找到对应的全局变量并写入姿态值
local GLOBAL_VAR_MAPPING = {
    -- 料仓1上相机标定
    ["1,1"] = {blockName = "标定坐标", varName = "料仓1上相机标定"},
    ["1,2"] = {blockName = "标定坐标", varName = "料仓2上相机标定"},
    ["1,3"] = {blockName = "标定坐标", varName = "料仓3上相机标定"},

--1吸头下相机标定
    ["1,4"] = {blockName = "标定坐标", varName = "吸头1上相机标定"},   --这里可能有一个错误,吸头1上相机标定应该为吸头1下相机标定
    ["1,5"] = {blockName = "标定坐标", varName = "吸头2下相机标定"},
    ["1,6"] = {blockName = "标定坐标", varName = "吸头3下相机标定"},
    ["1,7"] = {blockName = "标定坐标", varName = "吸头4下相机标定"},
    ["1,8"] = {blockName = "标定坐标", varName = "吸头1标定放料位"},
    
    -- 料仓拍照坐标
    ["2,1"] = {blockName = "拍照坐标", varName = "料仓1拍照坐标"},
    ["2,2"] = {blockName = "拍照坐标", varName = "料仓2拍照坐标"},
    
    -- 取料坐标
    ["3,1"] = {blockName = "取料坐标", varName = "吸头1取料坐标"},
    ["3,2"] = {blockName = "取料坐标", varName = "吸头2取料坐标"},
    ["3,3"] = {blockName = "取料坐标", varName = "吸头3取料坐标"},
    ["3,4"] = {blockName = "取料坐标", varName = "吸头4取料坐标"},
    
    -- 贴装补偿量
    ["4,1"] = {blockName = "贴装补偿量", varName = "贴装补偿1"},
    ["4,2"] = {blockName = "贴装补偿量", varName = "贴装补偿2"},
    ["4,3"] = {blockName = "贴装补偿量", varName = "贴装补偿3"},
    ["4,4"] = {blockName = "贴装补偿量", varName = "贴装补偿4"},
    
    -- 取料补偿量
    ["5,1"] = {blockName = "取料补偿量", varName = "取料补偿1"},
    ["5,2"] = {blockName = "取料补偿量", varName = "取料补偿2"},
    ["5,3"] = {blockName = "取料补偿量", varName = "取料补偿3"},
    ["5,4"] = {blockName = "取料补偿量", varName = "取料补偿4"},
    
    -- 取料补偿量
    ["6,1"] = {blockName = "贴装坐标", varName = "贴装1"},
    ["6,2"] = {blockName = "贴装坐标", varName = "贴装2"},
    ["6,3"] = {blockName = "贴装坐标", varName = "贴装3"},
    ["6,4"] = {blockName = "贴装坐标", varName = "贴装4"},
    
     --[[ 映射点 浮点数点
    ["7,1"] = {blockName = "映射点", varName = "吸头1映射点1"},
    ["7,2"] = {blockName = "映射点", varName = "吸头1映射点2"},
    ["7,3"] = {blockName = "映射点", varName = "吸头2映射点1"},
    ["7,4"] = {blockName = "映射点", varName = "吸头2映射点2"},
    ["7,5"] = {blockName = "映射点", varName = "吸头3映射点1"},
    ["7,6"] = {blockName = "映射点", varName = "吸头3映射点2"},
    ["7,7"] = {blockName = "映射点", varName = "吸头4映射点1"},
    ["7,8"] = {blockName = "映射点", varName = "吸头4映射点2"},
    
     -- 取料补偿量 浮点数点
    ["10,1"] = {blockName = "取料示教点位", varName = "相机中心"},
    ["10,2"] = {blockName = "取料示教点位", varName = "吸嘴中心"},
    ["10,3"] = {blockName = "取料示教点位", varName = "图像中心点"],
    ]]

}
---全局变量映射表
-- 带名称前缘的坐标类指令配置
-- 格式: [指令名称] = {blockName = "全局变量块名", varName = "变量名"}
--示例: 发送指令【坐标1,100.0,200.0,0.0】  将收到到的名称在映射表中找到对应的全局变量并写入姿态值
local COORDINATE_CONFIG = {
    -- 基本示例
    --["料仓上相机标定1"] = {blockName = "标定坐标", varName = "料仓上相机标定1"},
    --["坐标2"] = {blockName = "标定坐标", varName = "料仓上相机标定2"},
    --
    ---- 吸头下相机标定
    --["吸头1"] = {blockName = "标定坐标", varName = "吸头1下相机标定"},
    --["吸头2"] = {blockName = "标定坐标", varName = "吸头2下相机标定"},
}

-- ==================== 核心函数 (通常无需修改) ====================

--[[
触发指定流程
@param lineName 流程名称
]]
function triggerLineByName(lineName)
    if not lineName or #lineName == 0 then
        LuaLog:WriteLog("错误", "流程名称为空")
        return false
    end

--LuaLog:WriteLog("触发流程", lineName)
    local result = LuaSystem:TriggerLineByName(0, lineName)
    
    if result then
        LuaLog:WriteLog("触发成功", lineName)
    else
        LuaLog:WriteLog("错误", "触发流程失败: " .. lineName)
    end
    
    return result

end

--[[
写入全局变量
@param blockIndex 全局变量块索引
@param varIndex 变量索引
@param value 坐标值
]]
function writeToGlobal_idx(blockIndex, varIndex, value)
    --WriteGlobalPosture函数没有通过索引写入全局变量的方法,需要建立一个索引与全局变量的映射表
    --示例：   "1,1/0.0.0,0.0.0,0.0.0"  //料仓1标定位
    --1,1表示需要将此数据填充至视觉1,1位置的全局变量
    --/号分离索引与数据

--通过映射表去映射转成全局变量索引与全局变量名称
    --writeToGlobal_idx函数就是调用影射表来实现写入全局变量 
    
    -- 构建索引键
    local indexKey = tostring(blockIndex) .. "," .. tostring(varIndex)
    
    -- 查找映射配置
    local config = GLOBAL_VAR_MAPPING[indexKey]
    
    if not config then
        LuaLog:WriteLog("错误", "未找到对应的全局变量映射: " .. indexKey)
        return false
    end
    
    if not value then
        LuaLog:WriteLog("错误", "坐标值为空")
        return false
    end
    
    LuaLog:Debug("通过索引写入全局变量", indexKey .. " -> " .. config.blockName .. "." .. config.varName)
    
    -- 调用写入函数
    local result = LuaGlobalVar:WriteGlobalPosture(config.blockName, config.varName, value)
    
    if result then
        LuaLog:WriteLog("写入成功", config.blockName .. "." .. config.varName)
    else
        LuaLog:WriteLog("错误", "写入全局变量失败: " .. config.blockName .. "." .. config.varName)
    end
    
    return result

end

--[[
写入全局变量
@param blockName 全局变量块名称
@param varName 变量名称
@param value 坐标值
]]
function writeToGlobal(blockName, varName, value)
    if not value then
        LuaLog:WriteLog("错误", "坐标值为空")
        return false
    end

LuaLog:Debug("写入全局变量", blockName .. "." .. varName)
    local result = LuaGlobalVar:WriteGlobalPosture(blockName, varName, value)
    
    if result then
        LuaLog:WriteLog("写入成功", blockName .. "." .. varName)
    else
        LuaLog:WriteLog("错误", "写入全局变量失败: " .. blockName .. "." .. varName)
    end
    
    return result

end

--[[
触发指令处理
@param command 指令字符串
]]
function processSimpleTrigger(command)
    for prefix, lineName in pairs(TRIGGER_CONFIG) do
        if LuaString:StartWith(command, prefix) then
            return triggerLineByName(lineName)
        end
    end
    return false
end

--[[
坐标指令处理
格式: 坐标名称,x,y,r
示例: 坐标1,100.0,200.0,0.0
]]
function processSimpleCoordinate(command)
    local parts = LuaString:Split(command, ",")
    if parts:length() == 4 then
        local coordName = parts[0]
        local x = LuaString:ToReal(parts[1], 0)
        local y = LuaString:ToReal(parts[2], 0)
        local r = LuaString:ToReal(parts[3], 0)

local config = COORDINATE_CONFIG[coordName]
        if config then
            local value = cyPosture(x, y, r)
            return writeToGlobal(config.blockName, config.varName, value)
        else
            LuaLog:WriteLog("错误", "未知的坐标名称: " .. coordName)
        end
    end
    return false

end

--[[
带全局变量索引前缀的坐标指令处理
格式: blockIndex,varIndex/x,y,r
示例: 1,1/100.0,200.0,0.0
]]
function processIndexedCoordinate(command)
    -- 使用Split方法按斜杠分割字符串
    local parts = LuaString:Split(command, "/")
    if parts:length() ~= 2 then
        LuaLog:Debug("调试", "不是带索引的坐标格式: " .. command)
        return false
    end

local indexPart = parts[0]  -- 索引部分，如 "1,1"
    local coordPart = parts[1]  -- 坐标部分，如 "100.0,200.0,0.0"
    
    -- 解析索引部分
    local indexParts = LuaString:Split(indexPart, ",")
    if indexParts:length() ~= 2 then
        LuaLog:WriteLog("错误", "索引格式错误: " .. indexPart)
        return false
    end
    
    local blockIndex = indexParts[0]
    local varIndex = indexParts[1]
    
    --if blockIndex <= 0 or varIndex <= 0 then
        --LuaLog:WriteLog("错误", "索引值必须大于0: " .. indexPart)
        --return false
    --end
    
    -- 解析坐标部分
    local coordParts = LuaString:Split(coordPart, ",")
    if coordParts:length() ~= 3 then
        LuaLog:WriteLog("错误", "坐标格式错误: " .. coordPart)
        return false
    end
    
    local x = LuaString:ToReal(coordParts[0], 0)
    local y = LuaString:ToReal(coordParts[1], 0)
    local r = LuaString:ToReal(coordParts[2], 0)
    
    LuaLog:Debug("解析坐标", string.format("blockIndex=%s, varIndex=%s, x=%.3f, y=%.3f, r=%.3f", 
        blockIndex, varIndex, x, y, r))
    
    -- 创建坐标对象
    local value = cyPosture(x, y, r)
    
    -- 写入全局变量
    return writeToGlobal_idx(blockIndex, varIndex, value)

end

--[[
主处理函数
]]
function main()
    local testCmd="1,1/100.3,200.4,10.1"
    local debug=false
    if debug then
        readval=testCmd
    else
        readVal=IN1
    end
    if not readVal or #readVal == 0 then
        LuaLog:WriteLog("警告", "输入值为空")
        return
    end

LuaLog:Debug("收到指令", readVal)
    -- 1. 首先尝试简单触发指令
    if processSimpleTrigger(readVal) then
        return
    end
    -- 2. 尝试处理带全局变量索引前缀的坐标指令
    if processIndexedCoordinate(readVal) then
        return
    end
    -- 3. 尝试简单坐标指令用来解析带全局变量名称的坐标指令
    if processSimpleCoordinate(readVal) then
        return
    end
    -- 4. 如果没有匹配任何指令
    LuaLog:WriteLog("错误", "无法识别的指令格式: " .. readVal)

end

-- ==================== 执行入口 ====================
main()
```