优化通信

yanjinhui

2025-03-26 72fdccd147d416cd27c3374b25cb2f5896d86b6f

 ÏîÄ¿´úÂë/WIDESEAWCS_Server Õýʽ/WIDESEAWCS_Tasks/SerialPort/SerialPortJob.cs

@@ -3,26 +3,35 @@
using System.Drawing.Imaging;
using System.IO.Ports;
using System.Linq;
using System.Net.WebSockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using AutoMapper;
using HslCommunication.WebSocket;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using Quartz;
using SqlSugar;
using StackExchange.Profiling.Internal;
using WIDESEA_ISerialPortRepository;
using WIDESEA_SerialPortRepository;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_DTO.SerialPort;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.DTO;
using WIDESEAWCS_QuartzJob.StackerCrane.Enum;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using WIDESEAWCS_Tasks.StackerCraneJob;
using WIDESEAWCS_TaskInfoService;
using WIDESEAWCS_Tasks.SerialPort;

namespace WIDESEAWCS_Tasks
{
    [DisallowConcurrentExecution]
    public class SerialPortJob : JobBase, IJob, IDisposable
    public class SerialPortJob : JobBase, IJob,IDisposable
    {
        public void Dispose()
        {
@@ -45,12 +54,26 @@
        private readonly IPutakeRepository _putakeRepository;
        private readonly IProcessRepository _processRepository;
        private readonly ITorqueOpRepository _orqueOpRepository;
        public SerialPortJob(IPutakeRepository putakeRepository, IProcessRepository processRepository, ITorqueOpRepository torqueOpRepository)

        private WebSocketServer _webSocketContext;
        private readonly IProcessServer _processServer;
        private readonly IPutakeServer _putakeServer;
        private readonly ITorqueOpServer _torqueOpServer;

       static string takeid = ""; // åœ¨å¾ªçŽ¯å¼€å§‹å‰å£°æ˜Ž takeid

        public SerialPortJob(ITorqueOpServer torqueOpServer,IPutakeServer putakeServer,IProcessServer processServer, IPutakeRepository putakeRepository, IProcessRepository processRepository, ITorqueOpRepository torqueOpRepository, WebSocketServer webSocketContext)
        {
            _putakeRepository = putakeRepository;
            _processRepository = processRepository;
            _orqueOpRepository = torqueOpRepository;
            _webSocketContext = webSocketContext;
            _processServer = processServer;
            _putakeServer = putakeServer;
            _torqueOpServer= torqueOpServer;    
        }



        public Task Execute(IJobExecutionContext context)
        {
@@ -60,6 +83,7 @@
                if (serialPortDevice != null)
                {
                    List<DeviceProDTO> deviceProDTOs = serialPortDevice.DeviceProDTOs;
                    
                    foreach (var item in deviceProDTOs)
                    {
                        if (item.DeviceProParamName != CommandType.Get.ToString() && item.DeviceProParamName != CommandType.Set.ToString())
@@ -67,109 +91,24 @@
                            DeviceProtocolDetailDTO? deviceProtocolDetail = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandType) && x.ProtocolDetailType == nameof(CommandType.Set));
                            if (deviceProtocolDetail != null)
                            {

                                //先查状态和组，按时间降序
                                string group = item.DeviceProDataBlock;


                                //这里判断组别三个看是那个，就查那个工艺表的值
                                if (group == "电气")
                                {
                                    
                                    //        å…ˆçœ‹Dt_TorqueOp表，查询到现在这条数据的任务号和步骤
                                    var take = _putakeRepository.QueryData(x => x.Pustatus == 2 && x.Grouptype == group).OrderBy(x => x.Dispatchtime).First();
                                    if (take==null)
                                string group = item.DeviceProDataBlock;//组别
                                if (group == "电气" || group == "地沟" || group == "机械")
                                { // **查询任务信息一次**
                                    var takeResponse = _putakeServer.PerformTasks(group);
                                    if (takeResponse == null || !takeResponse.Status)
                                    {
                                        //等于空就停
                                        Console.WriteLine($"任务分级表接口错误：{takeResponse?.Message}");
                                        continue;
                                    }

                                    //查到有该条数据了
                                    var process = _processRepository.QueryData(x => x.CraftType == group).OrderBy(x => x.SetpNum).First();



                                    float torqueone = process.TorqueOne;//读到值了
                                    float torquetow = process.TorqueTwo;
                                    if (torqueone != 0)
                                    var take = JsonConvert.DeserializeObject<Dt_Putake>(JsonConvert.SerializeObject(takeResponse.Data));
                                    takeid = take?.Njtakeid; // ç¼“存任务号
                                    if (takeid != null)
                                    {
                                        serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue.Replace("[setNum]", (torqueone * 1000).ToString().PadLeft(7, '0')) + "\r");
                                        //这里给它设完值就  æŸ¥å­˜å‚¨å€¼è¡¨ è¿™ä¸ªæ•°æ®æ˜¯å¦æ»¡è¶³äº†ï¼Œæ»¡è¶³äº†å°±è¿›è¡Œä¸‹ä¸€ä¸ªå€¼ï¼Œä¸æ»¡è¶³å°±ä¸å˜ä¸€ç›´ç»™å€¼
                                     var num=   _orqueOpRepository.QueryData(x => x.TakeId == take.Njtakeid && x.GroupOp == group && x.TorqueSize == torqueone).Count();
                                        if (num!= process.TorqueOneQuantity)
                                        {

                                        }

                                        ProcessElectricTask(group, serialPortDevice, item, deviceProtocolDetail, takeid);
                                    }
                                    if (torquetow != 0)
                                    {
                                        serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue.Replace("[setNum]", (torquetow * 1000).ToString().PadLeft(7, '0')) + "\r");
                                    }

                                    //        // è®¡ç®—当前步骤所需的 Torque æ€»æ•°
                                    int requiredTorqueCount = process.TorqueOneQuantity + process.TorqueTwoQuantity;

                                    // æŸ¥è¯¢å½“前步骤的 TorqueOp è®°å½•ï¼ŒåŒ¹é… ProcessSte和组，检查是否达到要求
                                    int torqueCount = _orqueOpRepository.QueryData(x => x.ProcessSte == process.SetpNum && x.GroupOp == group).Count();

                                    if (torqueCount < requiredTorqueCount)
                                    {
                                        // å¦‚果数量不满足，停止读取

                                        break;
                                    }
                                #region

                                //    //先看工艺表中步骤一中要扭的值有多少个 å†æŸ¥çœ‹Dt_TorqueOp表中是否有该任务号id和步骤总数是否满足工艺表
                                //    // æŸ¥è¯¢æ‰€æœ‰å·¥è‰ºæ•°æ®ï¼ŒæŒ‰ç…§æ­¥éª¤å· SetpNum é€’增排序                                                                                                                                            
                                //    var processList = _processRepository.QueryData(x => x.CraftType == group)
                                //                                        .OrderBy(x => x.SetpNum)
                                //                                        .ToList();

                                //    foreach (var process in processList)
                                //    {
                                //        float  torqueone = process.TorqueOne;//读到值了
                                //        float torquetow = process.TorqueTwo;
                                //        if (torqueone!=0)
                                //        {
                                //            serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue.Replace("[setNum]", (torqueone * 1000).ToString().PadLeft(7, '0')) + "\r");
                                //        }
                                //        if (torquetow != 0)
                                //        {
                                //            serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue.Replace("[setNum]", (torquetow * 1000).ToString().PadLeft(7, '0')) + "\r");
                                //        }

                                //        // è®¡ç®—当前步骤所需的 Torque æ€»æ•°
                                //        int requiredTorqueCount = process.TorqueOneQuantity + process.TorqueTwoQuantity;

                                //        // æŸ¥è¯¢å½“前步骤的 TorqueOp è®°å½•ï¼ŒåŒ¹é… ProcessSte和组，检查是否达到要求
                                //        int torqueCount = _orqueOpRepository.QueryData(x => x.ProcessSte == process.SetpNum&& x.GroupOp== group).Count();

                                //        if (torqueCount < requiredTorqueCount)
                                //        {
                                //            // å¦‚果数量不满足，停止读取

                                //            break;
                                //        }
                                //        //符合要求，继续读取下一步

                            }

                                //}
                                //if (group == "机械")
                                //{

                                //}
                                //if (group == "地沟")
                                //{

                                //}
                                #endregion


                                serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue.Replace("[setNum]", (5 * 1000).ToString().PadLeft(7, '0')) + "\r");
                                //打开串口时先设值
                                item.DeviceProParamName = CommandType.Set.ToString();
                                }
                                item.DeviceProParamName = CommandType.None.ToString();
                            }
                        }

@@ -180,28 +119,19 @@
                            if (deviceProtocolDetail != null)
                            {
                                serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue, "\r");//打开串口时先设值

                                WriteDebug("写入", item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue);
                            }
                        }
                        else if (CommandType.Set.ToString() == item.DeviceProParamName)
                        {
                            DeviceProtocolDetailDTO? deviceProtocolDetail = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandType) && x.ProtocolDetailType == nameof(CommandType.Set));
                            //设值
                            if (deviceProtocolDetail != null)
                            {
                                serialPortDevice.Communicator.Write(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue, "\r");//打开串口时先设值
                            }
                        }



                        if (serialPortDevice.Communicator.Buffers.Count > 0)
                        {
                            string? receiveData = serialPortDevice.Communicator.ToString(Encoding.Default);
                            if (!string.IsNullOrEmpty(receiveData))
                            {
                                Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + receiveData);
                                Console.WriteLine("serialPortDevice:" + DateTime.Now.ToString("HH:mm:ss.fff") + receiveData);

                                if (item.DeviceProParamName == CommandType.Set.ToString())
                                if (item.DeviceProParamName == CommandType.Set.ToString() || item.DeviceProParamName == CommandType.None.ToString())
                                {
                                    DeviceProtocolDetailDTO? deviceProtocolDetail = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandResult) && x.ProtocolDetailType == nameof(CommandResult.SetOK));
                                    //parseok 
@@ -209,63 +139,46 @@
                                    {
                                        item.DeviceProParamName = CommandType.Get.ToString();




                                    }
                                }
                                else if (item.DeviceProParamName == CommandType.Get.ToString())
                                {
                                    DeviceProtocolDetailDTO? deviceProtocolDetail = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandResult) && x.ProtocolDetailType == nameof(CommandResult.GetOK));
                                    //03成功

                                    if (deviceProtocolDetail != null && receiveData.Contains(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue))
                                    {
                                        ////这里成功之后，要存储到看Dt_TorqueOp（存任务号，组，值）
                                        //string group = "";
                                        //if (group == "电气")
                                        //{
                                        //    var putake = _putakeRepository.QueryData(x => x.Pustatus == 2 && x.Grouptype == group).OrderByDescending(x => x.Dispatchtime).FirstOrDefault();//每次都拿最早的那条
                                        //    var punjid = putake.ID;
                                        //    var Nj = new Dt_TorqueOp()
                                        //    {
                                        //        TakeId = putake.Njtakeid,
                                        //        GroupOp = group,
                                        //        //ProcessSte= processList
                                        //        TorqueSize = receiveData

                                        //    };
                                        //    _orqueOpRepository.AddData(Nj);

                                        //}
                                        //if (group == "机械")
                                        //{

                                        //}
                                        //if (group == "地沟")


                                            item.DeviceProParamName = CommandType.Set.ToString();
                                        //把这条数据插入op表中
                                        string group = item.DeviceProDataBlock; // è®¾å¤‡æ‰€å±žç»„别
                                        string devicecode = item.DeviceChildCode;//设备编号
                                        string torqueValue = ExtractTorqueValue(receiveData);//调用转值方法
                                        if (group == "电气" || group == "地沟" || group == "机械")
                                        {
                                            if (takeid != null)
                                            {
                                                SaveTorqueOpData(group, devicecode, torqueValue, takeid);
                                            }
                                          
                                            item.DeviceProParamName = CommandType.None.ToString();
                                        }

                                    }
                                }
                                else if (item.DeviceProParamName == CommandType.Get.ToString())
                                {
                                    DeviceProtocolDetailDTO? deviceProtocolDetail = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandResult) && x.ProtocolDetailType == nameof(CommandResult.GetError));
                                    if (deviceProtocolDetail != null && receiveData.Contains(item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue))

                                    DeviceProtocolDetailDTO? deviceProtocolDetail2 = serialPortDevice.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(CommandResult) && x.ProtocolDetailType == nameof(CommandResult.GetError));
                                    if (deviceProtocolDetail2 != null && receiveData.Contains(item.DeviceChildCode + deviceProtocolDetail2.ProtocalDetailValue))
                                    {
                                        item.DeviceProParamName = CommandType.Set.ToString();



                                        item.DeviceProParamName = CommandType.None.ToString();
                                    }
                                }
                            }


                            //建一个对象将其传给前端
                            //string data = JsonConvert.SerializeObject(serialPortDevice);//这里serialPortDevice是假设有这个对象
                            //_webSocketContext.PublishAllClientPayload(data);
                        }

                    }

                }

            }
            catch (Exception ex)
            {
@@ -274,5 +187,202 @@
            WriteDebug("CommonConveyorLineJob", "test");
            return Task.CompletedTask;
        }

        /// <summary>
        /// å°†0004000转为4.0
        /// 0004500转为4.5
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private string ExtractTorqueValue(string data)
        {
            string[] parts = data.Split(','); // æŒ‰é€—号分割数据
            if (parts.Length > 1) // ç¡®ä¿è‡³å°‘有两个部分
            {
                //返回的是一个类似于82407024103,+0005433,0004500,1702485619
                string targetValue = parts[1].TrimStart('+'); // ç§»é™¤å‰å¯¼ '+'
                if (Regex.IsMatch(targetValue, @"^\d+$")) // ç¡®ä¿æ˜¯çº¯æ•°å­—
                {
                    return (double.Parse(targetValue) / 1000.0).ToString("0.###"); // é™¤ä»¥ 1000，保留最多 3 ä½å°æ•°
                }
            }
            return "0.000"; // è§£æžå¤±è´¥è¿”回 0.000
        }


  

        /// <summary>
        /// å¤„理电气任务逻辑，发送扭矩指令到设备
        /// </summary>
        /// <param name="group">任务分组</param>
        /// <param name="serialPortDevice">串口设备</param>
        /// <param name="item">设备信息</param>
        /// <param name="deviceProtocolDetail">设备协议详情</param>
        private void ProcessElectricTask(string group, SerialPortDevice serialPortDevice, DeviceProDTO item, DeviceProtocolDetailDTO deviceProtocolDetail,string takeid)
        {
            //1.获取当前任务号  //IPutakeServer里面的待执行的第一条任务；
            //var take = _putakeRepository.QueryData(x => x.Grouptype == group)
            //    .OrderBy(x => x.Dispatchtime)
            //    .FirstOrDefault();
           

            //2.调用Getcircuit拿到当前步骤
            var process = _processServer.Getcircuit(group, takeid);

            if (process != null && process.Status)
            {
                var list = JsonConvert.SerializeObject(process.Data);
                var data = JsonConvert.DeserializeObject<ProcessData>(list);

                if (data?.proNow != null)
                {

                    int setpNum = data.proNow.SetpNum;
                    int sum = data.proNow.TorqueSum;
                    double torqueone = data.proNow.TorqueOne;
                    double torquetwo = data.proNow.TorqueTwo;

                    int onequantity = data.proNow.TorqueOneQuantity;
                    int towquantity = data.proNow.TorqueTwoQuantity;


                    //判断op表中这个值是否有该条任务的数据
                    //var op = _orqueOpRepository.QueryData(x => x.TakeId == takeid && x.GroupOp == group && x.ProcessSte == setpNum);
                    // 3. æŸ¥è¯¢æ‰­çŸ©è®°å½•
                    var opResponse = _torqueOpServer.WhetherSaveValueData(takeid, group, setpNum);
                    if (opResponse == null || !opResponse.Status || opResponse.Data == null)
                    {
                        Console.WriteLine($"WhetherSaveValueData接口错误：{opResponse?.Message}");
                        return;
                    }

                    var op = JsonConvert.DeserializeObject<List<Dt_TorqueOp>>(JsonConvert.SerializeObject(opResponse.Data)); // ç¡®ä¿è½¬æ¢æ­£ç¡®


                    if (op.Any())//判断是否有数据
                    {
                        //找到了就要对比现在op表中有多少条，是否和工艺表中的目标一致

                        // è®¡ç®—第一个扭矩的数量（在 Â±1 è¯¯å·®èŒƒå›´å†…）//Math.Abs(5.2 - 4.5) = 0.7 // è®¡å…¥ Math.Abs(6.0 - 4.5) = 1.5 ä¸è®¡å…¥
                        var oponecount = op.Count(x => Math.Abs(x.TorqueSize - torqueone) <= 1);

                        int times = 0;
                        if (op.Count() > onequantity)
                        {
                            times = onequantity;//如果第一条以及满足就移除onequantity数量的数据
                        }
                        else
                        {
                            times = op.Count();//没有满足就移除当前的数据数据
                        }

                        for (int i = 0; i < times; i++)
                        {
                            //移除第一次值的影响（以为有可能俩个目标值相近而产生误判）
                            op.RemoveAt(0); //移除 op åˆ—表的 ç¬¬ä¸€ä¸ªå…ƒç´ ï¼ˆå³æœ€æ—©å­˜å…¥çš„记录）

                        }

                        // è®¡ç®—第二个扭矩的数量（在 Â±1 è¯¯å·®èŒƒå›´å†…）
                        var optowcount = op.Count(x => Math.Abs(x.TorqueSize - torquetwo) <= 1);
                        sum = oponecount + optowcount;
                        //第一种，第一个扭力值没有扭完
                        if (oponecount < onequantity && torqueone != 0)
                        {
                            //设值
                            //var com = item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue
                            //        .Replace("[setNum]", (torqueone * 1000).ToString().PadLeft(7, '0')) + "\r";
                            var com = item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue
                                      .Replace("[setNum]", Math.Round(torqueone * 1000).ToString().PadLeft(7, '0')) + "\r";
                            //格式化成整数

                            serialPortDevice.Communicator.Write(com);
                            //WriteDebug("写入", com);
                        }
                        //第二种，第一个值扭完了，第二个没有扭完
                        if (oponecount == onequantity && optowcount < towquantity && torquetwo != 0)
                        {
                            //设值
                            var com = item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue
                                    .Replace("[setNum]", Math.Round(torquetwo * 1000).ToString().PadLeft(7, '0')) + "\r";
                            serialPortDevice.Communicator.Write(com);
                        }
                    }
                    //这里这个任务第一次执行，op表中肯定是没有数据的，所有第一次就要把工艺表中的值给它
                    else if(!op.Any()&& torqueone!=0)//防止步骤一中torqueone的值为0导致报错
                    {
                        //设值
                        var com = item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue
                                .Replace("[setNum]", Math.Round(torqueone * 1000).ToString().PadLeft(7, '0')) + "\r";
                        serialPortDevice.Communicator.Write(com);
                    }

                }
                else
                {
                    Console.WriteLine("proNow ä¸ºç©º");
                }
            }
            else
            {
                Console.WriteLine($"Getcireit接口错误：{process?.Message}");
            }
        }

        /// <summary>
        /// å‘送扭矩指令到设备
        /// </summary>
        /// <param name="serialPortDevice">串口设备</param>
        /// <param name="item">设备信息</param>
        /// <param name="deviceProtocolDetail">设备协议详情</param>
        /// <param name="torqueValue">扭矩值</param>
        private void SendTorqueCommand(SerialPortDevice serialPortDevice, DeviceProDTO item, DeviceProtocolDetailDTO deviceProtocolDetail, double torqueValue)
        {
            var com = item.DeviceChildCode + deviceProtocolDetail.ProtocalDetailValue
                        .Replace("[setNum]", Math.Round(torqueValue * 1000).ToString().PadLeft(7, '0')) + "\r";
            serialPortDevice.Communicator.Write(com);
        }


        /// <summary>
        /// å­˜å‚¨æ‰­çŸ©æ•°æ®åˆ° `op` è¡¨
        /// </summary>
        private void SaveTorqueOpData(string group, string devicecode, string torqueValue,string takeid)
        {
        
            //调用Getcircuit拿到当前步骤
            var process = _processServer.Getcircuit(group, takeid);

            if (process != null && process.Status)
            {
                var list = JsonConvert.SerializeObject(process.Data);
                var dataz = JsonConvert.DeserializeObject<ProcessData>(list);

                if (dataz?.proNow != null)
                {

                    int setpNum = dataz.proNow.SetpNum;
                    int sum = dataz.proNow.TorqueSum;
                    double torqueone = dataz.proNow.TorqueOne;
                    int onequantity = dataz.proNow.TorqueOneQuantity;
                    int towquantity = dataz.proNow.TorqueTwoQuantity;
                    double torquetwo = dataz.proNow.TorqueTwo;
                    Dt_TorqueOp Addop = new Dt_TorqueOp()
                    {
                        DeviceCode = devicecode,
                        TakeId = takeid,
                        GroupOp = group,
                        ProcessSte = setpNum,
                        TorqueSize = float.TryParse(torqueValue, out float torque) ? torque : 0.0f, // è¿™é‡Œè¿›è¡Œå­—符串到float的转换
                        CreateDate = DateTime.Now,
                    };
                    //_orqueOpRepository.AddData(Addop);
                    _torqueOpServer.AddData(Addop);


                }
            }
        }
    }
}