htl_httpserver/deviceHttpServer/mazak/MazakServer.cs

using Newtonsoft.Json;
using RequestServer.HttpServer;
using ResponseServer.HttpServer;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.NetworkInformation;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static MaCls;

namespace HttpServer.mazak
{
    class MazakServer
    {
        private static string ON_LINE_STATE = "在线";
        private static Dictionary<short, string> runModeDict = new Dictionary<short, string>();
        public MazakServer()
        {
            runModeDict.Add(0, "No operation mode");
            runModeDict.Add(1, "Automatic operation mode");
            runModeDict.Add(2, "Tape operation mode");
            runModeDict.Add(3, "Rapid traverse mode");
            runModeDict.Add(4, "Home return mode");
            runModeDict.Add(5, "Cutting feed/manual pulse mode");
            runModeDict.Add(6, "MDI operation mode");
        }
       
        static ushort h;
        public ResponseBody requestHttpServer(RequestBody<ToolData> requestBody)
        {
            string ip = requestBody.serverUrl;
            string port = requestBody.port;
            string fun = requestBody.type; 

            YG.Log.Instance.WriteLogAdd($"mazak-请求参数-->> " + JsonConvert.SerializeObject(requestBody));
            ResponseBody responseBody = new ResponseBody();
            responseBody.deviceState = ON_LINE_STATE;

            Ping pingSender = new Ping();
            PingReply reply = pingSender.Send(ip);
            if (reply.Status != IPStatus.Success)
            {
                responseBody.deviceState = "离线";
                responseBody.msg = "网络不通";
                responseBody.result = false;
            }
            else
            {
                // port = 50100;
                int ret = MaCls.MazConnect(out h, ip, 50100, 10);
                YG.Log.Instance.WriteLogAdd($"mazak-连接结果-->> " + ret);
                if(ret != 0)
                {
                    responseBody.msg = "机床" + ip + "连接失败";
                    responseBody.result = false;
                    return responseBody;
                }
                RunDatasInfo runDataInfo = new RunDatasInfo();
                if (fun == ActionTypeEnum.Collect.ToString())
                {
                    ushort status0 = 0;
                    short status = 1;
                    ret = MaCls.MazGetRunningSts(h, status0, ref status);
                    YG.Log.Instance.WriteLogAdd($"mazak-status-->> " + status);
                    MAZ_NCONTIME powerTime = default(MAZ_NCONTIME);
                    ret = MaCls.MazGetNcPowerOnTime(h, ref powerTime);
                    if(ret == 0)
                    {
                        runDataInfo.powerOnTime = powerTime.year.ToString() + "/" + powerTime.uint_0.ToString() + "/" + powerTime.uint_1.ToString() + " " 
                            + powerTime.uint_2.ToString() + ":" + powerTime.AnonymousMember1.ToString() + ":" + powerTime.uint_3.ToString();
                    }

                    //获取轴名称
                    MAZ_AXISNAME axisNameInfo = default(MAZ_AXISNAME); 
                    ret = MaCls.MazGetAxisName(h, ref axisNameInfo);
                    if(ret == 0)
                    { 
                        foreach(OneAxisName axisName in axisNameInfo.axis)
                        {

                        }
                        YG.Log.Instance.WriteLogAdd($"mazak-轴名称-->> " + axisNameInfo);
                        //当前位置
                        MAZ_NCPOS currentNcPos = default(MAZ_NCPOS);
                        ret = MaCls.MazGetCurrentPos(h, ref currentNcPos);
                        if(ret == 0)
                        {
                            runDataInfo.absoluteCoordinate = string.Join(",", currentNcPos.data); 
                        }
                        //相对位置
                        MAZ_NCPOS relativeNcPos = default(MAZ_NCPOS);
                        ret = MaCls.MazGetRemain(h, ref relativeNcPos);
                        if (ret == 0)
                        {
                            runDataInfo.relativeCoordinate = string.Join(",", relativeNcPos.data);
                        }
                        //机械位置
                        MAZ_NCPOS machineNcPos = default(MAZ_NCPOS);
                        ret = MaCls.MazGetMachinePos(h, ref machineNcPos);
                        if (ret == 0)
                        {
                            runDataInfo.machineCoordinate = string.Join(",", machineNcPos.data);
                        }

                    }
                    //主轴负载
                    ushort spindleLoad = 0;
                    ret = MaCls.MazGetSpindleLoad(h, 0, ref spindleLoad);
                    if (ret == 0)
                    {
                        runDataInfo.spindleLoad = spindleLoad.ToString();
                    }
                    //进给轴负载
                    ushort feedAxisLoad = 0;
                    ret = MaCls.MazGetSpindleLoad(h, 0, ref feedAxisLoad);
                    if (ret == 0)
                    {
                        runDataInfo.feedAxisLoad = feedAxisLoad.ToString();
                    }
                    //伺服轴负载
                    MAZ_AXISLOAD axisLoadInfo = default(MAZ_AXISLOAD);
                    ret = MaCls.MazGetAxisLoad(h, ref axisLoadInfo);
                    if (ret == 0)
                    {
                        runDataInfo.servoLoad = axisLoadInfo.data[0].ToString();
                        YG.Log.Instance.WriteLogAdd($"mazak-伺服轴负载-->> " + JsonConvert.SerializeObject(axisLoadInfo));
                    }
                    //主程序
                    MAZ_PROINFO proInfo = default(MAZ_PROINFO);
                    ret = MaCls.MazGetMainPro(h, status0, ref proInfo);
                    if (ret == 0)
                    {
                        runDataInfo.mainProg = proInfo.string_0;
                    }

                    //进给速度
                    MAZ_FEED maz_feed = default(MAZ_FEED);
                    ret = MaCls.MazGetFeed(h, status0, ref maz_feed);
                    if (ret == 0)
                    {
                        runDataInfo.actFeedSpeed = maz_feed.fmin.ToString();
                    }


                    //进给倍率1000
                    ushort feedOver = 0;
                    ret = MaCls.MazGetFeedOverRide(h, 0, ref feedOver);
                    if (ret == 0)
                    {
                        runDataInfo.feedRateOvr = feedOver.ToString();
                    }

                    //主轴速度
                    int spindleSpeed = 0;
                    ret = MaCls.MazGetCurrentSpindleRev(h, 0, ref spindleSpeed);
                    if (ret == 0)
                    {
                        runDataInfo.actSpindleSpeed = spindleSpeed.ToString();
                    }
                    //主轴倍率
                    ushort spindleRateOvr = 0;
                    ret = MaCls.MazGetSpindleOverRide(h, 0, ref spindleRateOvr);
                    if (ret == 0)
                    {
                        runDataInfo.spindleRateOvr = spindleRateOvr.ToString();
                    }

                    //NC版本信息
                    MAZ_NC_VERINFO nc_version = default(MAZ_NC_VERINFO);
                    ret = MaCls.MazGetNCVersionInfo(h, ref nc_version);
                    if (ret == 0)
                    {
                        runDataInfo.ncModel = nc_version.szNCModel;
                    }
                    //运行模式
                    short modeNum = 0;
                    ret = MaCls.MazGetRunMode(h, 0, ref modeNum);
                    if (ret == 0)
                    {
                        runDataInfo.runMode = runModeDict[modeNum];
                    }
                    
                    //运行时间
                    MAZ_NCTIME nc_time = default(MAZ_NCTIME);
                    ret = MaCls.MazGetRunningTime(h, 0, ref nc_time);
                    if (ret == 0)
                    {   
                        runDataInfo.ncRunTime = nc_time.uint_0.ToString() + "时" + nc_time.uint_1.ToString() + "分" + nc_time.uint_2.ToString() + "秒";
                    }
                    //工件计数
                    int partsCount = 0;
                    ret = MaCls.MazGetPartsCount(h, 0, ref partsCount);
                    if (ret == 0)
                    {
                        runDataInfo.partsCount = partsCount;
                    }
                    //当前刀号
                    MAZ_TOOLINFO currentToolInfo = default(MAZ_TOOLINFO);
                    ret = MaCls.MazGetCurrentTool(h, 0, ref currentToolInfo);
                    if (ret == 0)
                    {
                        runDataInfo.currentToolNo = currentToolInfo.ushort_0.ToString();
                    }

                    //报警
                    MAZ_ALARMALL maz_ALARMALL = default(MAZ_ALARMALL);
                    ret = MaCls.MazGetAlarm(h, ref maz_ALARMALL);
                    if (ret == 0)
                    {
                        MAZ_ALARM[] alarms = maz_ALARMALL.alarm;
                        if (alarms != null && alarms.Count() > 0)
                        {
                            List<AlmInfo> errors = new List<AlmInfo>();
                            foreach (MAZ_ALARM alarm in alarms)
                            {
                                AlmInfo addAlarm = new AlmInfo();
                                addAlarm.no = alarm.short_0.ToString();
                                addAlarm.msg = alarm.message;
                                errors.Add(addAlarm);

                            }
                            responseBody.errorsInfo = JsonConvert.SerializeObject(errors);
                            YG.Log.Instance.WriteLogAdd($"mazak-报警-->> " + JsonConvert.SerializeObject(alarms));
                        }

                    }
                    //获取刀具列表，先获取刀具数量
                    int toolNum = 0;
                    ret = MaCls.MazGetToolDataNum(h, 0, ref toolNum);

                    MAZ_TD[] array = new MAZ_TD[toolNum - 1 + 1];
                    ret = MaCls.MazGetAllToolData(h, 0, toolNum, array);
                    if (ret == 0)
                    {
                        if (array != null && array.Count() > 0)
                        {
                            List<ToolsInfo> tools = new List<ToolsInfo>();
                            foreach (MAZ_TD mazTd in array)
                            {
                                ToolsInfo addToolInfo = new ToolsInfo();
                                addToolInfo.tno = mazTd.td_common.ushort_0.ToString(); //刀号
                                addToolInfo.pkno = mazTd.td_common.pkno.ToString(); //刀位编号
                                addToolInfo.length = mazTd.td_common.lengthA.ToString(); //刀具长度
                                addToolInfo.name = mazTd.td_common.name.ToString(); //刀具名称
                                addToolInfo.int0 = mazTd.td_common.int_0.ToString(); //公称径
                                addToolInfo.diameter = mazTd.td_common.diameter.ToString(); //刀具径刀尖角
                                addToolInfo.lifetime = mazTd.td_common.lifetime.ToString(); //刀具额定使用寿命
                                addToolInfo.lifenumber = mazTd.td_common.lifenumber.ToString(); //刀具额定使用次数
                                addToolInfo.usetime = mazTd.td_common.usetime.ToString(); //刀具已使用寿命
                                addToolInfo.usenumber = mazTd.td_common.usenumber.ToString(); //刀具已使用次数
                                addToolInfo.int1 = mazTd.td_common.int_1.ToString(); //组号
                                addToolInfo.wearcompZ = mazTd.td_common.wearcompZ.ToString(); //磨损补偿
                                addToolInfo.maxwearZ = mazTd.td_common.maxwearZ.ToString(); //磨损极限
                                addToolInfo.angle = mazTd.td_various.td_general.td_general.angle.ToString(); //刀具补偿
                                addToolInfo.easycompX = mazTd.td_various.td_general.td_general.easycompX.ToString(); //最高转速
                                addToolInfo.easycompY = mazTd.td_various.td_general.td_general.easycompY.ToString(); //径量补偿
                                addToolInfo.conscompZ = mazTd.td_various.td_general.td_general.conscompZ.ToString(); //长度补偿
                                tools.Add(addToolInfo);
                            }
                            responseBody.toolsData = JsonConvert.SerializeObject(tools);
                        }
                        
                        YG.Log.Instance.WriteLogAdd($"mazak-获取刀具列表-->> 成功" + JsonConvert.SerializeObject(array));
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-获取刀具列表-->> 失败");
                    }
                    responseBody.runDatasInfo = JsonConvert.SerializeObject(runDataInfo);
                    //responseBody.runDatasInfo = "运行时间:" + powerTime.uint_2 + ",主程序:" + proInfo.string_0 + ",进给:" + maz_feed.fmin/1000 + ",主轴负载:" + spindleLoad + ",进给负载:" + feedOver
                    //                             + "，主轴速度:" + spindleSpeed + ",刀具信息:" + JsonConvert.SerializeObject(currentToolInfo);


                }
                else if (fun == ActionTypeEnum.ToolNoData.ToString())
                {
                    ushort toolno = 0;
                    MAZ_TDALL toollist = default(MAZ_TDALL);
                    ret = MaCls.MazGetToolData(h, 0, requestBody.toolNo, ref toollist);
                    if (ret == 0)
                    {
                        ToolData tool = new ToolData();
                        foreach (MAZ_TD aZ_TDALL in toollist.tool)
                        {
                            MAZ_TD td11 = new MAZ_TD();
                            td11 = aZ_TDALL;

                            if (aZ_TDALL.td_common.ushort_0 == requestBody.toolNo)
                            {
                                tool.pkno = td11.td_common.pkno;
                                tool.lengthA = td11.td_common.lengthA; //刀具长度 / 10000
                                tool.name = td11.td_common.name; //刀具名称对应key  （15 立铣，16 特殊 ）默认
                                tool.int0 = td11.td_common.int_0; //公称径 / 10
                                tool.diameter = td11.td_common.diameter; // 刀具径刀尖角 / 10000
                                tool.lifetime = td11.td_common.lifetime; //刀具寿命 /60
                                tool.lifenumber = td11.td_common.lifenumber; //刀具次数
                                tool.usetime = td11.td_common.usetime; //刀具使用时间 /60
                                tool.usenumber = td11.td_common.usenumber; //刀具使用次数
                                tool.int1 = td11.td_common.int_1; // 组号
                                tool.wearcompZ = td11.td_common.wearcompZ; //磨损补偿 / 10000
                                tool.maxwearZ = td11.td_common.maxwearZ; //磨损极限 /10000
                                tool.angle = td11.td_various.td_general.td_general.angle; //刀尖补偿 / 10000 最大值 32767
                                tool.easycompX = td11.td_various.td_general.td_general.easycompX; //最高转速 / 1000
                                tool.easycompY = td11.td_various.td_general.td_general.easycompY; //径补偿量 / 10000
                                tool.conscompZ = td11.td_various.td_general.td_general.conscompZ; //长度补偿 / 10000
                            }
                        }
                        responseBody.toolsData = JsonConvert.SerializeObject(tool);
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-获取刀具-->> 失败");
                    }
                }
                else if (fun == ActionTypeEnum.ToolList.ToString())
                {
                    int num = 0;
                    ret = MaCls.MazGetToolDataNum(h, 0, ref num);
                    responseBody.runDatasInfo = "刀具编号:" + num;
                    MAZ_TD[] array = new MAZ_TD[num - 1 + 1];
                    ret = MaCls.MazGetAllToolData(h, 0, num, array);
                    if (ret == 0)
                    {
                        responseBody.toolsData = JsonConvert.SerializeObject(array);
                        YG.Log.Instance.WriteLogAdd($"mazak-获取刀具列表-->> 成功" + JsonConvert.SerializeObject(array));
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-获取刀具-->> 失败");
                    }

                }
                else if (fun == ActionTypeEnum.DeleteTool.ToString())
                {
                    ret = MaCls.MazDeleteToolData(h, 0, requestBody.toolNo);
                    if (ret == 0)
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-删除刀具-->> 成功");
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-删除刀具-->> 失败");
                    }
                }
                else if (fun == ActionTypeEnum.SetTool.ToString())
                {
                    MAZ_TDALL toollist = default(MAZ_TDALL);
                    ret = MaCls.MazGetToolData(h, 0, requestBody.toolNo, ref toollist);

                    MAZ_TDALL toolData = new MAZ_TDALL();
                    MAZ_TD[] tool1 = new MAZ_TD[22];
                    int count = 0;
                    foreach (MAZ_TD aZ_TDALL in toollist.tool)
                    {
                        MAZ_TD td11 = new MAZ_TD();
                        td11 = aZ_TDALL;
                        
                        if (aZ_TDALL.td_common.ushort_0 == requestBody.toolNo)
                        {
                            // td11.uint_0 = uint.Parse(requestBody.value);
                            ToolData toolDataParam = requestBody.data;
                            //td11.td_common.pkno = toolDataParam.pkno; //刀位号--不更改刀位
                            //td11.td_common.byte_1 = 1; //刀具ID编号对应key
                            td11.td_common.lengthA = toolDataParam.lengthA; //刀具长度 / 10000
                            td11.td_common.name = toolDataParam.name; //刀具名称对应key  （15 立铣，16 特殊 ）
                            td11.td_common.int_0 = toolDataParam.int0; //公称径 / 10

                            td11.td_common.diameter = toolDataParam.diameter; // 刀具径刀尖角 / 10000
                            td11.td_common.string_0 = toolDataParam.string0; //材料，机床里要有(高速钢 硬质合金  金属陶瓷)
                            td11.td_common.lifetime = toolDataParam.lifetime; //刀具寿命 /60
                            td11.td_common.lifenumber = toolDataParam.lifenumber; //刀具次数
                            td11.td_common.usetime = toolDataParam.usetime; //刀具使用时间 /60
                            td11.td_common.usenumber = toolDataParam.usenumber; //刀具使用次数
                            td11.td_common.int_1 = toolDataParam.int1; // 组号

                            //td11.td_various.td_general.td_general.conscompZ = -3120;
                            // td11.td_common.compno = 1; //补偿编号
                            //td11.td_common.wearcompX = 1000;
                            //td11.td_common.wearcompY = -1000;
                            td11.td_common.wearcompZ = toolDataParam.wearcompZ; //磨损补偿 / 10000
                            //td11.td_common.maxwearX = 10000;
                            // td11.td_common.maxwearY = 22000;
                            td11.td_common.maxwearZ = toolDataParam.maxwearZ; //磨损极限 /10000
                            td11.td_various.td_general.td_general.angle = toolDataParam.angle; //刀尖补偿 / 10000 最大值 32767
                            td11.td_various.td_general.td_general.easycompX = toolDataParam.easycompX; //最高转速 / 1000
                            td11.td_various.td_general.td_general.easycompY = toolDataParam.easycompY; //径补偿量 / 10000
                            //td11.td_various.td_general.td_general.easycompZ = 2320;
                            //td11.td_various.td_general.td_general.conscompX = 2330;
                            //td11.td_various.td_general.td_general.conscompY = 2340;
                            td11.td_various.td_general.td_general.conscompZ = toolDataParam.conscompZ; //长度补偿 / 10000
                            //td11.td_common.lengthB = 1950000;//不用

                            //td11.td_common.dummy5 = "1";
                            //td11.td_common.compno = 2;
                        }
                        tool1[count] = td11;
                        count++;
                    }
                    toollist.tool = tool1;

                    MAZ_TD td1 = new MAZ_TD();

                    td1.td_common.ushort_0 = requestBody.toolNo;
                    td1.td_common.name = 33;
                    td1.td_common.pkno = 21;
                    td1.td_common.int_0 = 1;
                    // td1.td_common.lengthA = 10000+ requestBody.toolNo;
                    //td1.td_common.lengthB = 20000+ requestBody.toolNo;
                    MAZ_TD[] tool = new MAZ_TD[20];
                    tool[0] = td1;
                    //toolData.tool = tool;
                    //MAZ_TD td2 = default(MAZ_TD);
                    //td2.td_common.ushort_0 = 2;
                    //td2.td_common.name = 22;
                    //toolData.tool = td2;en  

                    MAZ_TD_ERRORALL errorData = default(MAZ_TD_ERRORALL);
                    ret = MaCls.MazSetToolData(h, 0, requestBody.toolNo, ref toollist, ref errorData);
                    if (ret == 0)
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-删除刀具-->> 成功");
                        responseBody.result = true;
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-删除刀具-->> 失败");
                        responseBody.result = false;
                        responseBody.msg = "mazak-删除刀具-->> 失败";
                    }
                }
                else if (!string.IsNullOrEmpty(requestBody.path))
                {
                    string fileName = Path.GetFileName(requestBody.path);
                    string filepath = Path.GetDirectoryName(requestBody.path);
                    YG.Log.Instance.WriteLogAdd($"mazak-fileName-->> " + fileName + ",filepath=" + filepath);
                    try
                    {
                        if (fun == ActionTypeEnum.Upload.ToString())
                        {
                            ret = MaCls.MazSendProgram(h, fileName, filepath, 1);
                            YG.Log.Instance.WriteLogAdd($"mazak-上传响应结果-->> " + ret);
                            if (ret == 0)
                            {   
                                YG.Log.Instance.WriteLogAdd($"mazak-上传-->> " + requestBody.path + "成功");
                                Thread.Sleep(2000);
                                string mainPro = fileName.Split('.')[0];
                                ret = MaCls.MazSetMainPro(h, 0, mainPro);
                                if (ret == 0)
                                {
                                    YG.Log.Instance.WriteLogAdd($"mazak-选择-->> " + mainPro + "成功");
                                    responseBody.result = true;
                                    responseBody.msg = "上传成功,设置主程序成功";
                                }
                                else
                                {
                                    responseBody.result = false;
                                    responseBody.msg = "上传成功,设置主程序失败";
                                    YG.Log.Instance.WriteLogAdd($"mazak-选择-->> " + mainPro + "失败");
                                }

                            }
                            else
                            {
                                responseBody.result = false;
                                responseBody.msg = "上传失败";
                                YG.Log.Instance.WriteLogAdd($"mazak-上传-->> " + requestBody.path + "失败");
                            }
                        }
                        else if (fun == ActionTypeEnum.DownLoad.ToString())
                        {
                            ret = MaCls.MazReceiveProgram(h, fileName, filepath, 1);
                            if (ret == 0)
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-下载-->> " + requestBody.path + "成功");
                            }
                            else
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-下载-->> " + requestBody.path + "失败");
                            }
                        }
                        else if (fun == ActionTypeEnum.DeleteNc.ToString())
                        {
                            ret = MaCls.MazDeleteProgram(h, fileName);
                            if (ret == 0)
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-删除-->> " + requestBody.path + "成功");
                            }
                            else
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-删除-->> " + requestBody.path + "失败");
                            }
                        }
                        else if (fun == ActionTypeEnum.SelectNcProgram.ToString())
                        {
                            ret = MaCls.MazSetMainPro(h, 0, fileName);
                            if (ret == 0)
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-选择-->> " + requestBody.path + "成功");
                            }
                            else
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-选择-->> " + requestBody.path + "失败");
                            }
                        }
                        else if (fun == ActionTypeEnum.UploadNoSet.ToString())
                        {
                            ret = MaCls.MazSendProgram(h, fileName, filepath, 1);
                            YG.Log.Instance.WriteLogAdd($"mazak-上传响应结果-->> " + ret);
                            if (ret == 0)
                            {
                                YG.Log.Instance.WriteLogAdd($"mazak-上传-->> " + requestBody.path + "成功");
                            }
                            else
                            {
                                responseBody.result = false;
                                responseBody.msg = "上传失败";
                                YG.Log.Instance.WriteLogAdd($"mazak-上传-->> " + requestBody.path + "失败");
                            }
                        }

                    }
                    catch (Exception e)
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-异常-->> " + e.Message);
                    }
                }
                else if(fun == ActionTypeEnum.SetMainProgram.ToString())
                {
                    ret = MaCls.MazSetMainPro(h, 0, requestBody.prgName);
                    if (ret == 0)
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-选择主程序-->> " + requestBody.prgName + "成功");
                        responseBody.result = true;
                        responseBody.msg = "设置主程序成功";
                    }
                    else
                    {
                        YG.Log.Instance.WriteLogAdd($"mazak-选择主程序-->> " + requestBody.prgName + "失败");
                        responseBody.result = false;
                        responseBody.msg = "设置主程序失败";
                    }
                }
                else if(fun == ActionTypeEnum.DeleteOrSetTool.ToString())
                {
                    if (true)
                    {
                        //初始化刀具数据
                        MAZ_TDALL toollist = default(MAZ_TDALL);
                        ret = MaCls.MazGetToolData(h, 0, requestBody.toolNo, ref toollist);

                        MAZ_TDALL toolData = new MAZ_TDALL();
                        MAZ_TD[] tool1 = new MAZ_TD[22];
                        int count = 0;
                        foreach (MAZ_TD aZ_TDALL in toollist.tool)
                        {
                            MAZ_TD td11 = new MAZ_TD();
                            td11 = aZ_TDALL;

                            if (aZ_TDALL.td_common.ushort_0 == requestBody.toolNo)
                            {
                                td11.td_common.lengthA = 0; //刀具长度 / 10000
                                td11.td_common.name = 15; //刀具名称对应key  （15 立铣，16 特殊 ）默认
                                td11.td_common.int_0 = 0; //公称径 / 10
                                td11.td_common.diameter = 0; // 刀具径刀尖角 / 10000
                                td11.td_common.lifetime = 0; //刀具寿命 /60
                                td11.td_common.lifenumber = 0; //刀具次数
                                td11.td_common.usetime = 0; //刀具使用时间 /60
                                td11.td_common.usenumber = 0; //刀具使用次数
                                td11.td_common.int_1 = 0; // 组号
                                td11.td_common.wearcompZ = 0; //磨损补偿 / 10000
                                td11.td_common.maxwearZ = 0; //磨损极限 /10000
                                td11.td_various.td_general.td_general.angle = 0; //刀尖补偿 / 10000 最大值 32767
                                td11.td_various.td_general.td_general.easycompX = 0; //最高转速 / 1000
                                td11.td_various.td_general.td_general.easycompY = 0; //径补偿量 / 10000
                                td11.td_various.td_general.td_general.conscompZ = 0; //长度补偿 / 10000
                            }
                            tool1[count] = td11;
                            count++;
                        }
                        toollist.tool = tool1;

                        MAZ_TD_ERRORALL errorData = default(MAZ_TD_ERRORALL);
                        ret = MaCls.MazSetToolData(h, 0, requestBody.toolNo, ref toollist, ref errorData);
                        if (ret == 0)
                        {
                            YG.Log.Instance.WriteLogAdd($"mazak-初始化刀具信息-->> 成功");
                            responseBody.result = true;
                            responseBody.toolsData = JsonConvert.SerializeObject(requestBody.data);
                        }
                        else
                        {
                            YG.Log.Instance.WriteLogAdd($"mazak-初始化刀具信息-->> 失败");
                            responseBody.result = false;
                            responseBody.msg = "mazak-初始化刀具信息-->> 失败";
                            return responseBody;
                        }
                    }
                    

                    if(requestBody.value == "set")
                    {
                        //设置刀具数据
                        MAZ_TDALL toollist = default(MAZ_TDALL);
                        ret = MaCls.MazGetToolData(h, 0, requestBody.toolNo, ref toollist);

                        MAZ_TDALL toolData = new MAZ_TDALL();
                        MAZ_TD[] tool1 = new MAZ_TD[22];
                        int count = 0;
                        foreach (MAZ_TD aZ_TDALL in toollist.tool)
                        {
                            MAZ_TD td11 = new MAZ_TD();
                            td11 = aZ_TDALL;

                            if (aZ_TDALL.td_common.ushort_0 == requestBody.toolNo)
                            {
                                ToolData toolDataParam = requestBody.data;
                                td11.td_common.lengthA = toolDataParam.lengthA; //刀具长度 / 10000
                                td11.td_common.name = toolDataParam.name; //刀具名称对应key  （15 立铣，16 特殊 ）
                                td11.td_common.int_0 = toolDataParam.int0; //公称径 / 10
                                td11.td_common.diameter = toolDataParam.diameter; // 刀具径刀尖角 / 10000
                                td11.td_common.lifetime = toolDataParam.lifetime; //刀具寿命 /60
                                td11.td_common.lifenumber = toolDataParam.lifenumber; //刀具次数
                                td11.td_common.usetime = toolDataParam.usetime; //刀具使用时间 /60
                                td11.td_common.usenumber = toolDataParam.usenumber; //刀具使用次数
                                td11.td_common.int_1 = toolDataParam.int1; // 组号
                                td11.td_common.wearcompZ = toolDataParam.wearcompZ; //磨损补偿 / 10000
                                td11.td_common.maxwearZ = toolDataParam.maxwearZ; //磨损极限 /10000
                                td11.td_various.td_general.td_general.angle = toolDataParam.angle; //刀尖补偿 / 10000 最大值 32767
                                td11.td_various.td_general.td_general.easycompX = toolDataParam.easycompX; //最高转速 / 1000
                                td11.td_various.td_general.td_general.easycompY = toolDataParam.easycompY; //径补偿量 / 10000
                                td11.td_various.td_general.td_general.conscompZ = toolDataParam.conscompZ; //长度补偿 / 10000

                                requestBody.data.pkno = td11.td_common.pkno;
                            }
                            tool1[count] = td11;
                            count++;
                        }
                        toollist.tool = tool1;

                        MAZ_TD_ERRORALL errorData = default(MAZ_TD_ERRORALL);
                        ret = MaCls.MazSetToolData(h, 0, requestBody.toolNo, ref toollist, ref errorData);
                        if (ret == 0)
                        {
                            YG.Log.Instance.WriteLogAdd($"mazak-设置刀具信息-->> 成功");
                            responseBody.result = true;
                            responseBody.toolsData = JsonConvert.SerializeObject(requestBody.data);
                        }
                        else
                        {
                            YG.Log.Instance.WriteLogAdd($"mazak-设置刀具信息-->> 失败");
                            responseBody.result = false;
                            responseBody.msg = "mazak-设置刀具信息-->> 失败";
                            return responseBody;
                        }
                    }

                }

                ret = MaCls.MazDisconnect(h);
                if (ret == 0)
                {
                    YG.Log.Instance.WriteLogAdd($"mazak-断开连接-->> 成功");
                    responseBody.result = true;
                }
                else
                {
                    YG.Log.Instance.WriteLogAdd($"mazak-断开连接-->> 失败");
                    responseBody.result = false;
                    responseBody.msg = "mazak-断开连接-->> 失败";
                }
            }
            return responseBody;
        }
    }
}