using HslCommunication;
using System;
using System.Collections.Generic;
using System.Text;
using WIDESEA_Common;
using WIDESEA_Common.LogEnum;
using WIDESEA_Core.EFDbContext;
using WIDESEA_Core.Utilities;
using WIDESEA_Entity.DomainModels;
using WIDESEA_Services;
using WIDESEA_Services.Repositories;
using WIDESEA_WCS.WCSClient;

namespace WIDESEA_WCS.Jobs.ConveyorLine.Logic
{
    public class MeasureLogic
    {

        /// <summary>
        /// 出库测量任务，当穿梭车放货后的处理逻辑
        /// </summary>
        /// <param name="taskNumber">任务号</param>
        /// <param name="dbContext"></param>
        /// <param name="client"></param>
        public static void DealWithMeasureOutLogic(VOLContext dbContext, PLCClient client, string station)
        {
            try
            {
                Dt_TaskWCSinfoRepository taskWCSinfoRepository = new Dt_TaskWCSinfoRepository(dbContext);

                //OperateResult<bool> tmplogicResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_Line_LoadSleep.ToString(), station);
                //if (!tmplogicResult.IsSuccess || !tmplogicResult.Content)
                //{
                //    return;
                //}

                //找对应任务类型：TaskType_Box_Pallet_Measure_Out，并且状态为TaskState_RGV_Finished的任务
                Dt_TaskWCSinfo measureOutTask = taskWCSinfoRepository.FindFirst(
                    x => x.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() &&
                    x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString() &&
                    x.wcstask_startPoint.Contains(station));
                if (measureOutTask == null)
                {
                    OperateResult<UInt32> taskRes_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station);
                    UInt32 _tasknum = taskRes_.Content;
                    measureOutTask = taskWCSinfoRepository.FindFirst(
                    x => x.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() &&
                    x.wcstask_taskNumber == _tasknum &&
                    x.wcstask_startPoint.Contains(station) && string.IsNullOrEmpty(x.wcstask_backUp_1));
                }
                if(measureOutTask == null)
                {
                    return;
                }

                int taskNumber = measureOutTask.wcstask_taskNumber;
                Dt_TaskWCSinfo taskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_taskNumber == taskNumber);
                if(taskWCSinfo != null)
                {
                    //查看线体状态，准备给线体下发任务信息
                    //读取逻辑控制值
                    OperateResult<Int16> logicResult = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_Measure_Out.ToString(), "Measure_O");
                    if (logicResult.IsSuccess)
                    {
                        Int16 logicValue = logicResult.Content;
                        Console.WriteLine($"逻辑控制值 = {logicValue}");
                        //说明工位在等待调度，准备下发任务
                        if (logicValue == 1 || logicValue == 2)
                        {
                            if (!taskWCSinfo.wcstask_state.Contains("Executing"))
                            {
                                //任务号--测量出库模式
                                bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Measure_Out.ToString(), taskWCSinfo.wcstask_taskNumber);
                                //托盘号--测量出库模式
                                bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Measure_Out.ToString(), taskWCSinfo.wcstask_barcode);
                                //起始站台--测量出库模式
                                bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Measure_Out.ToString(), taskWCSinfo.wcstask_startPoint);
                                //终点站台--测量出库模式
                                bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Measure_Out.ToString(), taskWCSinfo.wcstask_endPoint);

                                if (writeTaskNumber == true && writeBarcode == true &&
                                    writeStartStation == true && writeEndStation == true)
                                {
                                    Console.WriteLine($"{DateTime.Now}=>Success =>【测量出库任务】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");
                                }
                                else
                                {
                                    Console.WriteLine($"{DateTime.Now}=>::Failed:: =>【测量出库任务】给站台：【{taskWCSinfo.wcstask_startPoint}】,写到任务号：【{taskWCSinfo.wcstask_taskNumber}】，托盘号：【{taskWCSinfo.wcstask_barcode}】，终点：【{taskWCSinfo.wcstask_endPoint}】");
                                }
                            }                            
                        }
                        //说明站台已经收到任务数据，等待WCS的启动指令
                        else if (logicValue == 3)
                        {
                            //启动任务
                            bool startTask = client.WriteValue(CLineInfoDBName.W_Line_Logic_Measure_Out.ToString(), 1);
                            //入空托的时候，默认是托盘号核验一致
                            //bool checkFlag = client.WriteValue(CLineInfoDBName.W_Line_RFID_Done.ToString(), station.sm_stationNo, true);
                            if (startTask)
                            {
                                Console.WriteLine($"Success=>【测量出库任务】启动任务成功，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                            }
                            else
                            {
                                Console.WriteLine($"{DateTime.Now}=>Failed=> 【测量出库任务】启动任务失败，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                            }
                        }
                        else if (logicValue == 4 || logicValue == 5)
                        {
                            //读取RFID值，防止在logicValue == 3时更新任务状态失败
                            int station1 = int.Parse(taskWCSinfo.wcstask_startPoint);
                            OperateResult<UInt32> rfidResult_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station1.ToString());
                            OperateResult<UInt32> taskRes_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station1.ToString());
                            if (rfidResult_.IsSuccess && taskRes_.IsSuccess)
                            {
                                UInt32 _rfid = rfidResult_.Content;
                                UInt32 _tasknum = taskRes_.Content;
                                Dt_TaskWCSinfo _tmpTask = taskWCSinfoRepository.FindFirst(x =>
                                                x.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() &&
                                                x.wcstask_state == TaskState.TaskState_RGV_Finished.ToString() &&
                                                x.wcstask_taskNumber == _tasknum &&
                                                x.wcstask_barcode == _rfid.ToString());
                                if (_tmpTask != null)
                                {
                                    //启动成功后，在此更新任务状态、上报WMS任务状态
                                    WebResponseContent content = WMSApi.PostTaskStateToWMS(
                                        taskWCSinfo.wcstask_barcode,
                                        TaskState.TaskState_Measure_Out_Line_Executing.ToString());
                                    if (content.Status)
                                    {
                                        taskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Out_Line_Executing.ToString();
                                        taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                                        taskWCSinfoRepository.Update(taskWCSinfo, true);
                                        Console.WriteLine($"{DateTime.Now}=>Success=> 【测量出库任务】上报WMS更新任务状态成功【TaskState_Measure_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】");
                                    }
                                    else
                                    {
                                        Console.WriteLine($"{DateTime.Now}=>Failed=> 【测量出库任务】上报WMS更新任务状态出错【TaskState_Measure_Out_Line_Executing】，任务号：【{taskWCSinfo.wcstask_taskNumber}】，原因：{content.Message}");
                                    }
                                }
                            }

                            //清除测量出库模式下发的数据
                            //bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Measure_Out.ToString(), 0);
                            //bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Measure_Out.ToString(), 0);
                            //bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Measure_Out.ToString(), 0);
                            //bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Measure_Out.ToString(), 0);
                            //bool writelogicValue = client.WriteValue(CLineInfoDBName.W_Line_Logic_Measure_Out.ToString(), 0);
                        }
                        
                    } 
                }
                else
                {
                    Console.WriteLine($"出库测量任务，没有找到任务号对应的任务：{taskNumber}");
                }
            }
            catch(Exception ex)
            {
                Console.WriteLine($"出库测量任务，当穿梭车放货后的处理逻辑出现异常：{ex.Message}");
            }
        }


        /// <summary>
        /// 处理测量回库逻辑
        /// </summary>
        /// <param name="taskNumber">任务号</param>
        /// <param name="dbContext"></param>
        /// <param name="client"></param>
        public static void DealWithMeasureBackLogic(Dt_TaskWCSinfoRepository taskWCSinfoRepository, PLCClient client, string station)
        {
            //出库测量到达终点处理逻辑
            OperateResult<UInt32> rfidResult = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), station);
            //出库测量到达终点处理逻辑
            OperateResult<UInt32> taskResult = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), station);
            //机械手是否开始工作
            OperateResult<bool> workingResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_RobotArm_Catch_Moving.ToString(), "RobotArm");
            //读取轴承是否被机械手放回10301
            OperateResult<bool> backResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_RobotArm_Back_Normal.ToString(), "RobotArm");
            if (rfidResult.IsSuccess && taskResult.IsSuccess && backResult.IsSuccess)
            {
                string rfidValue = rfidResult.Content.ToString();
                //准备测量
                Dt_TaskWCSinfo taskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_barcode == rfidValue && x.wcstask_state == TaskState.TaskState_Measure_Out_Line_Executing.ToString());
                //测量中
                Dt_TaskWCSinfo back_TaskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_barcode == rfidValue && x.wcstask_state == TaskState.TaskState_Measureing.ToString());
                //测量完毕
                Dt_TaskWCSinfo backMoving_TaskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_barcode == rfidValue && (x.wcstask_state == TaskState.TaskState_Measure_Back_Line_Wait_Executing.ToString() || 
                    x.wcstask_state == TaskState.TaskState_Measure_Back_Line_Executing.ToString()));
                //有盘、有RFID、并且任务状态是：TaskState_Measure_Out_Line_Executing
                //说明是出库测量到达目的地
                if (taskWCSinfo != null)
                {
                    WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue, TaskState.TaskState_Measure_Out_Line_Finished.ToString());
                    if (content.Status)
                    {
                        taskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Out_Line_Finished.ToString();
                        taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                        taskWCSinfoRepository.Update(taskWCSinfo, true);
                        Console.WriteLine($"上报WMS，将【测量出库任务】任务状态修改为：【TaskState_Measure_Out_Line_Finished】成功！");
                        return;
                    }
                    else
                    {
                        Console.WriteLine($"::Error::=> 上报WMS，将【测量出库任务】任务状态修改为：【TaskState_Measure_Out_Line_Finished】出错，原因：{content.Message}");
                    }
                }
                //有盘、有RFID、并且任务状态是：TaskState_Measureing
                //说明是出库测量，测量完毕后，机械手把轴承放回该工位，准备走测量回库流程
                else if (back_TaskWCSinfo != null && backResult.Content)
                {
                    WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue, TaskState.TaskState_Measure_Back_Line_Wait_Executing.ToString());
                    if (content.Status)
                    {
                        //将任务类型改为回库中
                        back_TaskWCSinfo.wcstask_type = TaskType.TaskType_Box_Pallet_Measure_Back.ToString();
                        //将任务起始站台和目的站台对调，准备回库
                        back_TaskWCSinfo.wcstask_endPoint = back_TaskWCSinfo.wcstask_startPoint;
                        back_TaskWCSinfo.wcstask_startPoint = "10301";
                        back_TaskWCSinfo.wcstask_endLocation = back_TaskWCSinfo.wcstask_startLocation;
                        back_TaskWCSinfo.wcstask_startLocation = back_TaskWCSinfo.wcstask_endPoint;
                        back_TaskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Back_Line_Wait_Executing.ToString();
                        back_TaskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                        taskWCSinfoRepository.Update(back_TaskWCSinfo, true);

                        Console.WriteLine($"上报WMS，将【测量出库任务】任务状态修改为：【TaskState_Measure_Back_Line_Wait_Executing】成功，将任务类型改为：【TaskType_Box_Pallet_Measure_Back】，测量回库");
                    }
                    else
                    {
                        Console.WriteLine($"::Error::=> 上报WMS，将【测量出库任务】任务状态修改为：【TaskState_Measure_Back_Line_Wait_Executing】出错，原因：{content.Message}");
                    }

                }
                //说明可以开始回库流程了，开始调度逻辑
                else if (backMoving_TaskWCSinfo != null)
                {
                    //回库这里需要考虑冲突， 即穿梭车可能要放货到回库的目标地址，看是否有该类型已经开始
                    //出库测量任务
                    //起始站台为回库目的站台
                    //已经开始
                    //还没有到达托盘码校验位置
                    Dt_TaskWCSinfo tmpMeasureOutTask = taskWCSinfoRepository.FindFirst(x => 
                    x.wcstask_type == TaskType.TaskType_Box_Pallet_Measure_Out.ToString() && 
                    x.wcstask_startPoint.Contains(backMoving_TaskWCSinfo.wcstask_endPoint) && 
                    x.wcstask_state != TaskState.TaskState_Assigned.ToString()&&
                    string.IsNullOrEmpty(x.wcstask_backUp_1));
                    if(tmpMeasureOutTask != null)
                    {
                        Console.WriteLine($"当前有该站台：【{station}】的出库测量任务正在进行，回库任务：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】等待执行");

                        LogRecord.WriteLog(LogEnum.Measure, $"当前有该站台：【{station}】的出库测量任务正在进行，回库任务：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】等待执行");
                        return;
                    }

                    //读取逻辑控制值
                    OperateResult<Int16> logicResult = (OperateResult<Int16>)client.ReadValue(CLineInfoDBName.R_Line_Logic_Measure_Back.ToString(), "Measure_B");
                    if (logicResult.IsSuccess)
                    {
                        Int16 logicValue = logicResult.Content;
                        //说明工位在等待调度，准备下发任务
                        if (logicValue == 1 || logicValue == 2)
                        {
                            //任务号--测量回库模式
                            bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Measure_Back.ToString(), backMoving_TaskWCSinfo.wcstask_taskNumber);
                            //托盘号--测量回库模式
                            bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Measure_Back.ToString(), backMoving_TaskWCSinfo.wcstask_barcode);
                            //起始站台--测量回库模式
                            bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Measure_Back.ToString(), backMoving_TaskWCSinfo.wcstask_startPoint);
                            //终点站台--测量回库模式
                            bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Measure_Back.ToString(), backMoving_TaskWCSinfo.wcstask_endPoint);

                            if (writeTaskNumber == true && writeBarcode == true &&
                                writeStartStation == true && writeEndStation == true)
                            {
                                Console.WriteLine($"{DateTime.Now}=>Success => 【测量回库】给站台：【{backMoving_TaskWCSinfo.wcstask_startPoint}】,写到任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】，托盘号：【{backMoving_TaskWCSinfo.wcstask_barcode}】，终点：【{backMoving_TaskWCSinfo.wcstask_endPoint}】");
                            }
                            else
                            {
                                Console.WriteLine($"{DateTime.Now}=>::Failed:: => 【测量回库】给站台：【{backMoving_TaskWCSinfo.wcstask_startPoint}】,写到任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】，托盘号：【{backMoving_TaskWCSinfo.wcstask_barcode}】，终点：【{backMoving_TaskWCSinfo.wcstask_endPoint}】");
                            }
                        }
                        //说明站台已经收到任务数据，等待WCS的启动指令
                        else if (logicValue == 3)
                        {
                            //启动任务
                            bool startTask = client.WriteValue(CLineInfoDBName.W_Line_Logic_Measure_Back.ToString(), 1);
                            if (startTask)
                            {
                                Console.WriteLine($"Success=> 【测量回库】启动任务成功，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】");
                                //启动成功后，在此更新任务状态、上报WMS任务状态
                                //WebResponseContent content1 = WMSApi.PostTaskStateToWMS(
                                //    backMoving_TaskWCSinfo.wcstask_barcode,
                                //    TaskState.TaskState_Measure_Back_Line_Executing.ToString());
                                //if (content1.Status)
                                //{
                                //    backMoving_TaskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Back_Line_Executing.ToString();
                                //    backMoving_TaskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                                //    taskWCSinfoRepository.Update(backMoving_TaskWCSinfo, true);
                                //    Console.WriteLine($"{DateTime.Now}=>Success=> 【测量回库】上报WMS更新任务状态成功【TaskState_Measure_Back_Line_Executing】，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】");
                                //}
                                //else
                                //{
                                //    Console.WriteLine($"{DateTime.Now}=>Failed=> 【测量回库】上报WMS更新任务状态出错【TaskState_Measure_Back_Line_Executing】，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】，原因：{content1.Message}");
                                //}
                            }
                            else
                            {
                                Console.WriteLine($"{DateTime.Now}=>Failed=> 【测量回库】启动任务失败，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】");
                            }
                        }
                        else if (logicValue == 4 || logicValue == 5)
                        {
                            //读取RFID值，防止在logicValue == 3时更新任务状态失败
                            OperateResult<UInt32> rfidResult_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_Barcode.ToString(), backMoving_TaskWCSinfo.wcstask_startPoint);
                            OperateResult<UInt32> taskRes_ = (OperateResult<UInt32>)client.ReadValue(CLineInfoDBName.R_Line_TaskNumber.ToString(), backMoving_TaskWCSinfo.wcstask_startPoint);
                            if (rfidResult_.IsSuccess && taskRes_.IsSuccess)
                            {
                                UInt32 _rfid = rfidResult_.Content;
                                UInt32 _tasknum = taskRes_.Content;
                                Dt_TaskWCSinfo _tmpTask = taskWCSinfoRepository.FindFirst(x =>
                                                x.wcstask_taskNumber == _tasknum &&
                                                x.wcstask_barcode == _rfid.ToString());
                                if (_tmpTask != null)
                                {
                                    //启动成功后，在此更新任务状态、上报WMS任务状态
                                    WebResponseContent content1 = WMSApi.PostTaskStateToWMS(
                                        backMoving_TaskWCSinfo.wcstask_barcode,
                                        TaskState.TaskState_Measure_Back_Line_Executing.ToString());
                                    if (content1.Status)
                                    {
                                        backMoving_TaskWCSinfo.wcstask_state = TaskState.TaskState_Measure_Back_Line_Executing.ToString();
                                        backMoving_TaskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                                        taskWCSinfoRepository.Update(backMoving_TaskWCSinfo, true);
                                        Console.WriteLine($"{DateTime.Now}=>Success=> 【测量回库】上报WMS更新任务状态成功【TaskState_Measure_Back_Line_Executing】，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】");
                                    }
                                    else
                                    {
                                        Console.WriteLine($"{DateTime.Now}=>Failed=> 【测量回库】上报WMS更新任务状态出错【TaskState_Measure_Back_Line_Executing】，任务号：【{backMoving_TaskWCSinfo.wcstask_taskNumber}】，原因：{content1.Message}");
                                    }
                                }
                            }

                            //清除测量回库模式下发的数据
                            bool writeTaskNumber = client.WriteValue(CLineInfoDBName.W_TaskNumber_Measure_Back.ToString(), 0);
                            bool writeBarcode = client.WriteValue(CLineInfoDBName.W_RFID_Measure_Back.ToString(), 0);
                            bool writeStartStation = client.WriteValue(CLineInfoDBName.W_StartStation_Measure_Back.ToString(), 0);
                            bool writeEndStation = client.WriteValue(CLineInfoDBName.W_EndStation_Measure_Back.ToString(), 0);
                            bool writelogicValue = client.WriteValue(CLineInfoDBName.W_Line_Logic_Measure_Back.ToString(), 0);
                        }

                    }
                }               
            }

            //说明机械手在抓取轴承到测量设备，在此修改任务状态为：正在测量中
            if (workingResult.IsSuccess && workingResult.Content)
            {
                string rfidValue = rfidResult.Content.ToString();
                Dt_TaskWCSinfo taskWCSinfo = taskWCSinfoRepository.FindFirst(x => x.wcstask_barcode == rfidValue && x.wcstask_state == TaskState.TaskState_Measure_Out_Line_Finished.ToString());
                if (taskWCSinfo != null)
                {
                    WebResponseContent content = WMSApi.PostTaskStateToWMS(rfidValue, TaskState.TaskState_Measureing.ToString());
                    if (content.Status)
                    {
                        taskWCSinfo.wcstask_state = TaskState.TaskState_Measureing.ToString();
                        taskWCSinfo.wcstask_dispatcherTime = DateTime.Now;
                        taskWCSinfoRepository.Update(taskWCSinfo, true);
                        Console.WriteLine("机械手处于：抓取轴承到测量设备的运动过程中");
                    }
                    else
                    {
                        Console.WriteLine($"::Error::=> 上报WMS，将测量出库任务状态修改为：【TaskState_Measureing】出错，原因：{content.Message}");
                    }
                }
            }

            /***********************************************/
            /*****************机械手逻辑********************/
            /***********************************************/

            //查看机械手是否待测量等待状态
            OperateResult<bool> robotReadyResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_RobotArm_Ready.ToString(), "RobotArm");
            if (!robotReadyResult.IsSuccess)
            {
                Console.WriteLine("获取机械手状态失败");
                return;
            }
            if (robotReadyResult.Content)
            {
                //Console.WriteLine($"此时机械手状态--【处于】--等待状态");
                //通知机械手抓取轴承
                string _rfidValue = rfidResult.Content.ToString();
                Dt_TaskWCSinfo _taskWCSinfo = taskWCSinfoRepository.FindFirst(x =>
                                                x.wcstask_barcode == _rfidValue &&
                                                x.wcstask_state == TaskState.TaskState_Measure_Out_Line_Finished.ToString());
                if (_taskWCSinfo != null)
                {
                    //查看机械手是否已经启动
                    OperateResult<bool> robotWorkResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_RobotArm_Working.ToString(), "RobotArm");
                    if (robotWorkResult.IsSuccess && !robotWorkResult.Content)
                    {
                        //说明机械手还没启动，发送启动指令
                        bool catchFlag = client.WriteValue(CLineInfoDBName.W_RobotArm_Catch.ToString(), true);
                        if (catchFlag)
                        {
                            Console.WriteLine("机械手启动成功！");
                        }
                    }
                }
            }

            //查看机械手是否已经启动
            OperateResult<bool> _robotWorkResult = (OperateResult<bool>)client.ReadValue(CLineInfoDBName.R_RobotArm_Catch_Moving.ToString(), "RobotArm");
            if (_robotWorkResult.IsSuccess && _robotWorkResult.Content)
            {
                //启动成功后，置位机械手启动信号为 false
                bool resetFlag = client.WriteValue(CLineInfoDBName.W_RobotArm_Catch.ToString(), false);
                if (resetFlag)
                {
                    //Console.WriteLine("置位机械手启动信号！");
                }
            }

        }

    }
}