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("置位机械手启动信号！");
|
}
|
}
|
|
}
|
|
}
|
}
|
