icewint/wcs_server_kate_suzhou
5
2
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

<add>[important]电子标签基本完成

Browse Source
This commit is contained in:
葛林强 2024-05-30 15:34:20 +08:00
parent 46c9edc244
commit 21e3dedb78
37 changed files with 726 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
WcsMain/ApiServe/Controllers/Dto/WcsDto/ElTag/EditTaskInfoRequest.cs Normal file
View File

@ -0,0 +1,77 @@
using DataCheck;
using SqlSugar;
using System.Text.Json.Serialization;
namespace WcsMain.ApiServe.Controllers.Dto.WcsDto.ElTag;
public class EditTaskInfoRequest
{
/// <summary>
/// 任务号
/// </summary>
[DataRules]
[JsonPropertyName("taskId")]
public string? TaskId { get; set; }
/// <summary>
/// 点位
/// </summary>
[JsonPropertyName("location")]
public string? Location { get; set; }
/// <summary>
/// 订单号
/// </summary>
[JsonPropertyName("orderId")]
public string? OrderId { get; set; }
/// <summary>
/// 载具号
/// </summary>
[JsonPropertyName("vehicleNo")]
public string? VehicleNo { get; set; }
/// <summary>
/// 物料编号
/// </summary>
[JsonPropertyName("goodsId")]
public string? GoodsId { get; set; }
/// <summary>
/// 物料名称
/// </summary>
[JsonPropertyName("goodsName")]
public string? GoodsName { get; set; }
/// <summary>
/// 任务状态
/// </summary>
[JsonPropertyName("taskStatus")]
public int? TaskStatus { get; set; }
/// <summary>
/// 需求数量
/// </summary>
[JsonPropertyName("needNum")]
public int? NeedNum { get; set; }
/// <summary>
/// 拣选数量
/// </summary>
[JsonPropertyName("pickNum")]
public int? PickNum { get; set; }
/// <summary>
/// 创建人
/// </summary>
[JsonPropertyName("createPerson")]
public string? CreatePerson { get; set; }
/// <summary>
/// 备注
/// </summary>
[JsonPropertyName("remark")]
public string? Remark { get; set; }
}

47
WcsMain/ApiServe/Controllers/Dto/WcsDto/ElTag/QueryTaskRequest.cs Normal file
View File

@ -0,0 +1,47 @@
using System.Text.Json.Serialization;
namespace WcsMain.ApiServe.Controllers.Dto.WcsDto.ElTag;
public class QueryTaskRequest
{
/// <summary>
/// 查询的字符串
/// </summary>
[JsonPropertyName("searchStr")]
public string? SearchStr { get; set; }
/// <summary>
/// 任务状态
/// </summary>
[JsonPropertyName("elTagTaskStatus")]
public List<int>? TaskStatus { get; set; }
/// <summary>
/// 查询时间范围
/// </summary>
[JsonPropertyName("timeRange")]
public List<DateTime>? TimeRange { get; set; }
/// <summary>
/// 分页信息
/// </summary>
[JsonPropertyName("page")]
public ElTagTaskPage? Page { get; set; }
}
public class ElTagTaskPage
{
/// <summary>
/// 每页大小
/// </summary>
[JsonPropertyName("pageSize")]
public int PageSize { get; set; }
/// <summary>
/// 当前页数
/// </summary>
[JsonPropertyName("pageIndex")]
public int PageIndex { get; set; }
}

24
WcsMain/ApiServe/Controllers/WcsController/ElTagController.cs
View File

@ -4,6 +4,7 @@ using WcsMain.ApiServe.ControllerFilter.ExceptionFilter;
using WcsMain.ApiServe.Controllers.Dto;
using WcsMain.ApiServe.Controllers.Dto.WcsDto.ElTag;
using WcsMain.ApiServe.Service.WcsService;
using WcsMain.DataBase.TableEntity;
namespace WcsMain.ApiServe.Controllers.WcsController;
@ -32,5 +33,28 @@ public class ElTagController(ElTagService elTagService) : ControllerBase
}
/// <summary>
/// 分页查询电子标签任务表
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("queryTaskWithPage")]
public WcsApiResponse<int, List<AppElTagTask>> QueryTaskWithPage([FromBody] QueryTaskRequest request)
{
return _elTagService.QueryTaskWithPage(request);
}
/// <summary>
/// 编辑电子标签任务信息
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("editTaskInfo")]
public WcsApiResponse EditTaskInfo([FromBody] EditTaskInfoRequest request)
{
return _elTagService.EditTaskInfo(request);
}
}

39
WcsMain/ApiServe/Service/WcsService/ElTagService.cs
View File

@ -1,13 +1,18 @@
using WcsMain.ApiServe.Controllers.Dto;
using WcsMain.ApiServe.Controllers.Dto.WcsDto.ElTag;
using WcsMain.ApiServe.Factory;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.ApiServe.Service.WcsService;
[Service]
public class ElTagService
public class ElTagService(AppElTagTaskDao tagTaskDao)
{
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
/// <summary>
/// 展示电子标签的数字
/// </summary>
@ -17,4 +22,36 @@ public class ElTagService
{
return WcsApiResponseFactory.Fail();
}
/// <summary>
/// 分页查询电子标签任务
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public WcsApiResponse<int, List<AppElTagTask>> QueryTaskWithPage(QueryTaskRequest request)
{
(List<AppElTagTask>? elTagTasks, int totalRows) = _tagTaskDao.QueryWithPage(request);
if (elTagTasks == default)
{
return WcsApiResponseFactory.DataBaseErr<int, List<AppElTagTask>>();
}
return WcsApiResponseFactory.Success(totalRows, elTagTasks);
}
/// <summary>
/// 编辑电子标签任务信息
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public WcsApiResponse EditTaskInfo(EditTaskInfoRequest request)
{
var updateResult = _tagTaskDao.Update(new AppElTagTask
{
TaskId = request.TaskId,
TaskStatus = request.TaskStatus,
Remark = "WCS变更信息"
});
return updateResult > 0 ? WcsApiResponseFactory.Success() : WcsApiResponseFactory.DataBaseErr();
}
}

4
WcsMain/ApiServe/Service/WcsService/RunningInfoService.cs
View File

@ -31,7 +31,9 @@ public class RunningInfoService
{
fileNames.Add(fileInfo.Name);
}
return WcsApiResponseFactory.Success(fileNames, "查询成功");
var fileNameArray = fileNames.ToArray();
Array.Reverse(fileNameArray);
return WcsApiResponseFactory.Success(fileNameArray.ToList(), "查询成功");
}
/// <summary>

2
WcsMain/ApiServe/Service/WcsService/StackerService.cs
View File

@ -5,7 +5,7 @@ using WcsMain.ApiServe.Controllers.Dto.WcsDto.Stacker;
using WcsMain.ApiServe.Factory;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.PlcOperation.Stacker;
using WcsMain.EquipOperation.Stacker;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.ApiServe.Service.WcsService;

4
WcsMain/Business/CirculationTask/CommonCirculation/ConnectPlcWithCirculation.cs
View File

@ -1,8 +1,8 @@
using CirculateTool;
using WcsMain.Common;
using WcsMain.PlcOperation;
using WcsMain.EquipOperation;
namespace WcsMain.Business.CirculationTask;
namespace WcsMain.Business.CirculationTask.CommonCirculation;
/// <summary>
/// 定时器检测 PLC 是否连接，若没有连接则重新连接

2
WcsMain/Business/CirculationTask/CommonCirculation/HeartBeat.cs
View File

@ -1,5 +1,5 @@
using CirculateTool;
using WcsMain.PlcOperation;
using WcsMain.EquipOperation.Convey;
namespace WcsMain.Business.CirculationTask.CommonCirculation;

14
WcsMain/Business/CirculationTask/ElTag/LightElTag.cs
View File

@ -5,16 +5,18 @@ using WcsMain.DataBase.TableEntity;
using WcsMain.ElTag.Atop;
using WcsMain.ElTag.Atop.Entity;
using WcsMain.Enum.TaskEnum;
using WcsMain.EquipOperation.ElTag;
namespace WcsMain.Business.CirculationTask.ElTag;
[Circulation]
public class LightElTag(AppElTagTaskDao tagTaskDao, ConnectOprServe connectOprServe)
public class LightElTag(AppElTagTaskDao tagTaskDao, AtopOperation atopOperation, AppElTagBaseDao elTagBaseDao)
{
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly ConnectOprServe _connectOprServe = connectOprServe;
private readonly AtopOperation _atopOperation = atopOperation;
private readonly AppElTagBaseDao _elTagBaseDao = elTagBaseDao;
/// <summary>
/// 点亮电子标签
@ -55,16 +57,20 @@ public class LightElTag(AppElTagTaskDao tagTaskDao, ConnectOprServe connectOprSe
return;
}
/* 点亮标签 */
var resultException = _connectOprServe.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum);
var resultException = _atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum);
if(resultException == default )
{
ConsoleLog.Success($"点亮电子标签成功，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}");
_tagTaskDao.Update(new AppElTagTask
{
TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Lighting,
LightTime = DateTime.Now,
});
}); // 更新任务状态
_elTagBaseDao.Update(new AppElTagBase { Location = tagTask.Location, TaskId = tagTask.TaskId, LastLightTime = DateTime.Now }); // 更新点位状态，绑定任务
return;
}
ConsoleLog.Warning($"【警告】点亮电子标签失败，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}，异常信息：{resultException.Message}");
}
}

4
WcsMain/Business/CirculationTask/Stacker/CheckAccount.cs
View File

@ -4,9 +4,9 @@ using WcsMain.Common;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.Enum;
using WcsMain.EquipOperation.Entity;
using WcsMain.EquipOperation.Stacker;
using WcsMain.ExtendMethod;
using WcsMain.PlcOperation.Entity;
using WcsMain.PlcOperation.Stacker;
namespace WcsMain.Business.CirculationTask.Stacker;

6
WcsMain/Business/CirculationTask/Stacker/ExeTaskDoubleFork.cs
View File

@ -7,10 +7,10 @@ using WcsMain.DataBase.TableEntity;
using WcsMain.DataService;
using WcsMain.Enum.Stacker;
using WcsMain.Enum.TaskEnum;
using WcsMain.EquipOperation.Convey;
using WcsMain.EquipOperation.Entity.Stacker;
using WcsMain.EquipOperation.Stacker;
using WcsMain.ExtendMethod;
using WcsMain.PlcOperation;
using WcsMain.PlcOperation.Entity.Stacker;
using WcsMain.PlcOperation.Stacker;
using static Dm.net.buffer.ByteArrayBuffer;
namespace WcsMain.Business.CirculationTask.Stacker;

4
WcsMain/Business/CirculationTask/Stacker/ExecuteWcsTask.cs
View File

@ -5,9 +5,9 @@ using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.Enum.Stacker;
using WcsMain.Enum.TaskEnum;
using WcsMain.EquipOperation.Entity.Stacker;
using WcsMain.EquipOperation.Stacker;
using WcsMain.ExtendMethod;
using WcsMain.PlcOperation.Entity.Stacker;
using WcsMain.PlcOperation.Stacker;
namespace WcsMain.Business.CirculationTask.Stacker;

4
WcsMain/Business/CirculationTask/StackerConvey/CheckAccount.cs
View File

@ -3,8 +3,8 @@ using WcsMain.Business.CommonAction;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.Enum;
using WcsMain.PlcOperation.Entity;
using WcsMain.PlcOperation.StackerConvey;
using WcsMain.EquipOperation.Entity;
using WcsMain.EquipOperation.StackerConvey;
namespace WcsMain.Business.CirculationTask.StackerConvey;

51
WcsMain/DataBase/Dao/AppElTagBaseDao.cs
View File

@ -25,6 +25,7 @@ public class AppElTagBaseDao
.WhereIF(queryData.ControllerDisplayName != default, w => w.ControllerDisplayName == queryData.ControllerDisplayName)
.WhereIF(queryData.Area != default, w => w.Area == queryData.Area)
.WhereIF(queryData.LedStatus != default, w => w.LedStatus == queryData.LedStatus)
.WhereIF(queryData.TaskId != default, w => w.TaskId == queryData.TaskId)
.WhereIF(queryData.Remark != default, w => w.Remark == queryData.Remark);
return sqlFuc.ToList();
}
@ -40,4 +41,54 @@ public class AppElTagBaseDao
/// </summary>
/// <returns></returns>
public List<AppElTagBase>? Query() => Query(new AppElTagBase());
/// <summary>
/// 根据主键更新，不更新null值
/// </summary>
/// <param name="appElTag"></param>
/// <returns></returns>
public int Update(AppElTagBase appElTag)
{
try
{
var sqlFuc = CommonTool.DbServe.Updateable(appElTag).IgnoreNullColumns();
return sqlFuc.ExecuteCommand();
}
catch(Exception ex) { _ = ex; return 0; }
}
/*******************************业务************************************/
/// <summary>
/// 重置绑定的任务信息
/// </summary>
/// <param name="location"></param>
/// <returns></returns>
public int ResetLocation(string location)
{
try
{
var sqlFuc = CommonTool.DbServe.Updateable<AppElTagBase>()
.SetColumns(s => s.LastLightTime == null)
.SetColumns(s => s.TaskId == null)
.Where(w => w.Location == location);
return sqlFuc.ExecuteCommand();
}
catch (Exception ex) { _ = ex; return 0; }
}
}

52
WcsMain/DataBase/Dao/AppElTagTaskDao.cs
View File

@ -1,4 +1,5 @@
using WcsMain.Common;
using WcsMain.ApiServe.Controllers.Dto.WcsDto.ElTag;
using WcsMain.Common;
using WcsMain.DataBase.TableEntity;
using WcsMain.WcsAttribute.AutoFacAttribute;
@ -27,6 +28,7 @@ public class AppElTagTaskDao
.WhereIF(queryData.TaskStatus != default, w => w.TaskStatus == queryData.TaskStatus)
.WhereIF(queryData.NeedNum != default, w => w.NeedNum == queryData.NeedNum)
.WhereIF(queryData.PickNum != default, w => w.PickNum == queryData.PickNum)
.WhereIF(queryData.CreatePerson != default, w => w.CreatePerson == queryData.CreatePerson)
.WhereIF(queryData.Remark != default, w => w.Remark == queryData.Remark);
return sqlFuc.ToList();
}
@ -63,4 +65,52 @@ public class AppElTagTaskDao
}
}
/****************************************业务************************************/
/// <summary>
/// 分页查询 电子标签任务表
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public (List<AppElTagTask>? elTagTasks, int totalRows) QueryWithPage(QueryTaskRequest request)
{
try
{
int totalRows = 0;
var sqlFuc = CommonTool.DbServe.Queryable<AppElTagTask>()
.WhereIF(!string.IsNullOrEmpty(request.SearchStr),
w => w.TaskId!.Contains(request.SearchStr!)
|| w.Location!.Contains(request.SearchStr!)
|| w.VehicleNo!.Contains(request.SearchStr!)
|| w.GoodsId!.Contains(request.SearchStr!)
|| w.Remark!.Contains(request.SearchStr!));
if(request.TaskStatus != default)
{
List<int?> taskStatus = [];
request.TaskStatus.ForEach(item => taskStatus.Add(item));
sqlFuc.Where(w => taskStatus.Contains(w.TaskStatus));
}
if (request.TimeRange is { Count: 2 }) // 时间范围
{
sqlFuc.Where(w => w.CreateTime > request.TimeRange[0] && w.CreateTime < request.TimeRange[1]);
}
sqlFuc.OrderByDescending(o => new { o.CreateTime });
var queryResult = sqlFuc.ToPageList(request.Page!.PageIndex, request.Page!.PageSize, ref totalRows);
return (queryResult, totalRows);
}
catch (Exception ex)
{
_ = ex;
return default;
}
}
}

12
WcsMain/DataBase/TableEntity/AppElTagBase.cs
View File

@ -48,6 +48,18 @@ public class AppElTagBase
[SugarColumn(ColumnName = "led_status")]
public int? LedStatus { get; set; }
/// <summary>
/// 上次点亮的时间
/// </summary>
[SugarColumn(ColumnName = "last_light_time")]
public DateTime? LastLightTime { get; set; }
/// <summary>
/// 当前点亮的任务号
/// </summary>
[SugarColumn(ColumnName = "task_id")]
public string? TaskId { get; set; }
/// <summary>
/// 备注
/// </summary>

22
WcsMain/DataBase/TableEntity/AppElTagTask.cs
View File

@ -1,4 +1,5 @@
using SqlSugar;
using System.Text.Json.Serialization;
namespace WcsMain.DataBase.TableEntity;
@ -9,78 +10,99 @@ public class AppElTagTask
/// 任务号
/// </summary>
[SugarColumn(ColumnName = "task_id", IsPrimaryKey = true)]
[JsonPropertyName("taskId")]
public string? TaskId { get; set; }
/// <summary>
/// 点位
/// </summary>
[SugarColumn(ColumnName = "location")]
[JsonPropertyName("location")]
public string? Location { get; set; }
/// <summary>
/// 订单号
/// </summary>
[SugarColumn(ColumnName = "order_id")]
[JsonPropertyName("orderId")]
public string? OrderId { get; set; }
/// <summary>
/// 载具号
/// </summary>
[SugarColumn(ColumnName = "vehicle_no")]
[JsonPropertyName("vehicleNo")]
public string? VehicleNo { get; set; }
/// <summary>
/// 物料编号
/// </summary>
[SugarColumn(ColumnName = "goods_id")]
[JsonPropertyName("goodsId")]
public string? GoodsId { get; set; }
/// <summary>
/// 物料名称
/// </summary>
[SugarColumn(ColumnName = "goods_name")]
[JsonPropertyName("goodsName")]
public string? GoodsName { get; set; }
/// <summary>
/// 任务状态
/// </summary>
[SugarColumn(ColumnName = "task_status")]
[JsonPropertyName("taskStatus")]
public int? TaskStatus { get; set; }
/// <summary>
/// 需求数量
/// </summary>
[SugarColumn(ColumnName = "need_num")]
[JsonPropertyName("needNum")]
public int? NeedNum { get; set; }
/// <summary>
/// 拣选数量
/// </summary>
[SugarColumn(ColumnName = "pick_num")]
[JsonPropertyName("pickNum")]
public int? PickNum { get; set; }
/// <summary>
/// 创建人
/// </summary>
[SugarColumn(ColumnName = "create_person")]
[JsonPropertyName("createPerson")]
public string? CreatePerson { get; set; }
/// <summary>
/// 任务创建时间
/// </summary>
[SugarColumn(ColumnName = "create_time")]
[JsonPropertyName("createTime")]
public DateTime? CreateTime { get; set; }
/// <summary>
/// 点亮时间
/// </summary>
[SugarColumn(ColumnName = "light_time")]
[JsonPropertyName("lightTime")]
public DateTime? LightTime { get; set; }
/// <summary>
/// 确认时间
/// </summary>
[SugarColumn(ColumnName = "confirm_time")]
[JsonPropertyName("confirmTime")]
public DateTime? ConfirmTime { get; set;}
/// <summary>
/// 备注
/// </summary>
[SugarColumn(ColumnName = "remark")]
[JsonPropertyName("remark")]
public string? Remark { get; set; }

11
WcsMain/ElTag/Atop/AtopEnum/AtopSubCommandEnum.cs Normal file
View File

@ -0,0 +1,11 @@
namespace WcsMain.ElTag.Atop.AtopEnum;
public enum AtopSubCommandEnum
{
Confirm = 6, // 确认
StockOut = 7, // 缺货
TimeOut = 10, // 超时
ErrInstruct = 12, // 指令非法
Stuck = 13, // 卡键 ---- 按键按下未弹起
Others = 100, // 其他，灯不亮
}

109
WcsMain/ElTag/Atop/BaseOprDataHandler.cs
View File

@ -1,8 +1,13 @@
using WcsMain.Common;
using WcsMain.Tcp.Client;
using WcsMain.Tcp.Entity;
using System.Text.RegularExpressions;
using WcsMain.Common;
using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.ElTag.Atop.AtopEnum;
using WcsMain.ElTag.Atop.Entity;
using WcsMain.Enum.TaskEnum;
using WcsMain.EquipOperation.ElTag;
using WcsMain.ExtendMethod;
using WcsMain.WcsAttribute.AutoFacAttribute;
using static SocketTool.SocketClient;
namespace WcsMain.ElTag.Atop;
@ -10,9 +15,103 @@ namespace WcsMain.ElTag.Atop;
/// 电子标签收到数据的数据处理类
/// </summary>
[Component]
public class BaseOprDataHandler
public class BaseOprDataHandler(AppElTagBaseDao tagBaseDao, AppElTagTaskDao tagTaskDao, AtopOperation atopOperation)
{
private readonly AppElTagBaseDao _tagBaseDao = tagBaseDao;
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
private readonly AtopOperation _atopOperation = atopOperation;
/// <summary>
/// 收到数据时的处理方法
/// </summary>
/// <param name="tcpServe"></param>
public void GetMsg(TagReturnInfo tcpServe)
{
Task.Factory.StartNew(() =>
{
switch (tcpServe.SubCommand)
{
case (int)AtopSubCommandEnum.Confirm: // 确认
Confirm(tcpServe);
break;
case (int)AtopSubCommandEnum.StockOut: // 缺货
goto case (int)AtopSubCommandEnum.Confirm;
case (int)AtopSubCommandEnum.TimeOut: // 超时
ConsoleLog.Exception($"【异常】电子标签反馈超时，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
break;
case (int)AtopSubCommandEnum.ErrInstruct: // 指令非法
ConsoleLog.Warning($"【警告】电子标签反馈指令非法，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
break;
case (int)AtopSubCommandEnum.Stuck: // 卡键
ConsoleLog.Warning($"【警告】电子标签反馈标签卡键，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
break;
}
});
if(tcpServe.SubCommand==(int)AtopSubCommandEnum.Confirm || tcpServe.SubCommand==(int)AtopSubCommandEnum.StockOut)
{
Task.Factory.StartNew(() => Confirm(tcpServe)); // 当确定拣选或者缺货时
return;
}
}
/// <summary>
/// 按下确认键
/// </summary>
/// <param name="tcpServe"></param>
public void Confirm(TagReturnInfo tcpServe)
{
/* 找出这个标签最新点亮的那条记录 */
List<AppElTagBase>? eltags = _tagBaseDao.Query(new AppElTagBase { ControllerDisplayName = tcpServe.ControllerDisplayName, TagId = tcpServe.TagId });
if(eltags == default)
{
ConsoleLog.Exception($"【异常】电子标签确认查询数据库标签信息失败，与数据库服务器连连接中断，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
_atopOperation.ShowMsg(tcpServe.ControllerDisplayName, tcpServe.TagId, tcpServe.Data); // 重新点亮标签
return;
}
if(eltags.Count < 1)
{
ConsoleLog.Warning($"【异常】电子标签确认按钮按下，该标签不在基础资料表，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
return;
}
/* 取最新一条记录 */
eltags = [.. eltags.OrderByDescending(el => el.LastLightTime)];
var eltag = eltags[0];
string? taskId = eltag.TaskId; // 获取任务号
if(string.IsNullOrEmpty(taskId) )
{
ConsoleLog.Warning($"【异常】电子标签确认按钮按下，该标签没有绑定的显示任务，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
return;
}
/* 获取该任务号对应的任务 */
List<AppElTagTask>? tagTasks = _tagTaskDao.Query(new AppElTagTask { TaskId = taskId });
if(tagTasks == default)
{
ConsoleLog.Exception($"【异常】电子标签确认查询数据库任务失败，与数据库服务器连连接中断，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
_atopOperation.ShowMsg(tcpServe.ControllerDisplayName, tcpServe.TagId, tcpServe.Data); // 重新点亮标签
return;
}
if (tagTasks.Count < 1)
{
ConsoleLog.Warning($"【异常】电子标签确认按钮按下，该标签对应的任务：{taskId} 不存在，控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
return;
}
var tagTask = tagTasks[0]; // 获取到的任务
int pickNum = Regex.Replace(tcpServe.Data!, "\\D", "").IsNumber() ? Convert.ToInt32(tcpServe.Data) : -1;
/* 更新任务状态为确认 */
_tagTaskDao.Update(new AppElTagTask() { TaskId = tagTask.TaskId, ConfirmTime = DateTime.Now, TaskStatus = (int)ElTagTaskStatusEnum.Confirm, PickNum = pickNum, Remark = "标签确认" });
/* 更新绑定的库位信息为空 */
_tagBaseDao.ResetLocation(eltag.Location!);
ConsoleLog.Success($"电子标签确认按钮按下，标签任务号：{tagTask.TaskId} 已经确认，箱号：{tagTask.VehicleNo}，拣选数量：{tagTask.NeedNum}({pickNum}) 控制器：{tcpServe.ControllerDisplayName}，标签号：{tcpServe.TagId}，数据：{tcpServe.Data}");
/* 发送WMS电子标签任务完成 */
// [TODO]
}
}

118
WcsMain/ElTag/Atop/ConnectOprServe.cs
View File

@ -8,6 +8,7 @@ using WcsMain.ElTag.Atop.Entity;
using WcsMain.Enum.General;
using WcsMain.Enum.TaskEnum;
using WcsMain.Enum.Tcp;
using WcsMain.EquipOperation.ElTag;
using WcsMain.Tcp.Entity;
using WcsMain.WcsAttribute.AutoFacAttribute;
@ -18,10 +19,12 @@ namespace WcsMain.ElTag.Atop;
/// </summary>
/// <param name="baseOprDataHandler"></param>
[Component]
public class ConnectOprServe(AppTcpDao tcpDao, BaseOprDataHandler baseOprDataHandler)
public class ConnectOprServe(AppTcpDao tcpDao, BaseOprDataHandler baseOprDataHandler, AtopOperation atopOperation, AppElTagTaskDao tagTaskDao)
{
private readonly AppTcpDao _tcpDao = tcpDao;
private readonly BaseOprDataHandler _baseOprDataHandler = baseOprDataHandler;
private readonly AtopOperation _atopOperation = atopOperation;
private readonly AppElTagTaskDao _tagTaskDao = tagTaskDao;
/// <summary>
/// 设置基本参数
@ -64,57 +67,42 @@ public class ConnectOprServe(AppTcpDao tcpDao, BaseOprDataHandler baseOprDataHan
public void ConnectSuccess(TcpServeConnectionData tcpServe)
{
ConsoleLog.Success($"电子标签：{tcpServe.TcpServe!.TcpIp} 连接成功");
if (CommonData.AppElTags == default || CommonData.AppElTags.Count < 1) return;
var tagInfos = CommonData.AppElTags.FindAll(f => f.ControllerDisplayName == tcpServe.DisplayName);
if (tagInfos == default) return;
foreach (var tagInfo in tagInfos)
_atopOperation.BlinkingAll(tcpServe);
/* 点亮数据库中正在点亮的标签 */
List<AppElTagTask>? tasks = _tagTaskDao.Query(new AppElTagTask { TaskStatus = (int)ElTagTaskStatusEnum.Lighting });
if (tasks == default)
{
//CommonTool.OprTcpClient.Send(TagSendInfo.SetTagModel(Convert.ToByte(tagInfo.TagId), TagMode.Picking), tagInfo.ControllerDisplayName!);
//CommonTool.OprTcpClient.Send(TagSendInfo.(Convert.ToByte(tagInfo.TagId)), tagInfo.ControllerDisplayName!);
ConsoleLog.Exception("【异常】查询 电子标签 任务失败，数据库连接异常");
Thread.Sleep(5000);
return;
}
for (int i = 0; i < 5; i++)
{
foreach (var tagInfo in tagInfos)
{
CommonTool.OprTcpClient.Send(TagSendInfo.ShowTagId(Convert.ToByte(tagInfo.TagId)), tagInfo.ControllerDisplayName!);
//CommonTool.OprTcpClient.Send(TagSendInfo.LedColor(Convert.ToByte(tagInfo.TagId), LedColor.Green), tagInfo.ControllerDisplayName!);
//ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, 999, ledStatus: LedStatus.LEDOn);
}
Thread.Sleep(200);
foreach (var tagInfo in tagInfos)
{
CommonTool.OprTcpClient.Send(TagSendInfo.TurnOffTag(Convert.ToByte(tagInfo.TagId)), tagInfo.ControllerDisplayName!);
}
Thread.Sleep(200);
}
tasks.ForEach(LightTask);
}
/// <summary>
/// 向标签发送一个显示值
/// 执行点亮标签任务
/// </summary>
/// <param name="controllerDisplayName"></param>
/// <param name="tagId"></param>
/// <param name="value"></param>
/// <param name="ledColor"></param>
/// <param name="ledStatus"></param>
/// <returns></returns>
public Exception? ShowMsg(string? controllerDisplayName, int? tagId, int? value, LedColor ledColor = LedColor.Green, LedStatus ledStatus = LedStatus._0_5secblinking)
/// <param name="tagTask"></param>
public void LightTask(AppElTagTask tagTask)
{
if(controllerDisplayName == default || tagId == default || value == default)
if (CommonData.AppElTags == default || CommonData.AppElTags.Count < 1) return;
var tagInfo = CommonData.AppElTags.Find(f => f.Location == tagTask.Location);
if (tagInfo == default) return;
/* 点亮标签 */
var resultException = _atopOperation.ShowMsg(tagInfo.ControllerDisplayName, tagInfo.TagId, tagTask.NeedNum);
if (resultException == default)
{
return new Exception("必须的值为空，无法发送电子标签");
ConsoleLog.Success($"启动重复点亮电子标签成功，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}");
_tagTaskDao.Update(new AppElTagTask
{
TaskId = tagTask.TaskId,
TaskStatus = (int)ElTagTaskStatusEnum.Lighting,
LightTime = DateTime.Now,
Remark = "重启点亮"
}); // 更新任务状态
return;
}
if (value > 999) value = 999;
byte[] elTagData = TagSendInfo.ShowValue(Convert.ToByte(tagId), value.ToString()!);
var sendResult = CommonTool.OprTcpClient.Send(elTagData, controllerDisplayName); // 显示字符
CommonTool.OprTcpClient.Send(TagSendInfo.LedColor(Convert.ToByte(tagId), ledColor), controllerDisplayName); // 显示颜色
CommonTool.OprTcpClient.Send(TagSendInfo.LedStatus(Convert.ToByte(tagId), ledStatus), controllerDisplayName); // 显示闪烁频率
if (sendResult.Success) return default;
return sendResult.Exception;
ConsoleLog.Warning($"【警告】启动重复点亮电子标签失败，点位：{tagTask.Location}，数据：{tagTask.NeedNum}，载具号：{tagTask.VehicleNo}，标签号：{tagInfo.TagId}，异常信息：{resultException.Message}");
}
@ -151,8 +139,52 @@ public class ConnectOprServe(AppTcpDao tcpDao, BaseOprDataHandler baseOprDataHan
}
returnInfo.Data = string.Join("", returnData);
}
/*-------------------------------------------------------------------*/
if (returnInfo.SubCommand == 9)
{
string p_str = "";
byte[] ccb_data = new byte[250];
for (int k = 8; k < datas.Length && k < 258; k++)
{
ccb_data[k - 8] = datas[k];
}
int maxid = DiagResult(ccb_data, ref p_str);
returnInfo.Data = p_str;
if (string.IsNullOrEmpty(returnInfo.Data.Trim()))
{
returnInfo.Data = string.Empty;
}
}
ConsoleLog.Info($"电子标签获取返回值：{returnInfo}");
_baseOprDataHandler.GetMsg(returnInfo);
}
private int DiagResult(byte[] ccb_data, ref string tagstr)
{
int k, tmp, maxid;
tagstr = "";
tmp = 0;
maxid = 0;
for (k = 1; k <= 250; k++)
{
if ((k - 1) % 8 == 0)
{
tmp = ccb_data[3 + (k - 1) / 8];
}
if (tmp % 2 != 1)
{
maxid = k;
tagstr += "1";
}
else
{
tagstr += "0";
}
tmp /= 2;
}
tagstr = tagstr[..maxid];
return maxid;
}

2
WcsMain/ElTag/Atop/Entity/TagReturnInfo.cs
View File

@ -59,6 +59,6 @@ public class TagReturnInfo
public override string ToString()
{
return $"控制器别称：{ControllerDisplayName}，标签Id：{TagId}，提交方式：{SubCommand}，提交数据：{Data}";
return $"控制器别称：{ControllerDisplayName}，标签Id：{TagId}，消息端口：{Port}，提交方式：{SubCommand}，按钮类型：{KeyType}，提交数据：{Data}";
}
}

62
WcsMain/ElTag/Atop/Entity/TagSendInfo.cs
View File

@ -134,16 +134,24 @@ public class TagSendInfo
/// <param name="tagId"></param>
/// <param name="value"></param>
/// <returns></returns>
public static byte[] ShowValue(byte tagId, string? value)
public static byte[] ShowValue(byte tagId, int? value)
{
if(string.IsNullOrEmpty(value)) value = string.Empty;
if(value.Length < 6)
string showStr;
if (value == default || value > 999)
{
value = value.PadLeft(6, '0');
showStr = "MAX";
}
else
{
value = value.Substring(value.Length - 6, 6);
showStr = value!.ToString()!;
}
if(showStr!.Length < 6)
{
showStr = showStr.PadLeft(6, '0');
}
else
{
showStr = showStr.Substring(showStr.Length - 6, 6);
}
byte[] data = new byte[15];
data[0] = 0x0f;
@ -152,9 +160,49 @@ public class TagSendInfo
data[6] = 0x00;
data[7] = tagId;
for (int i = 0; i < value.Length; i++)
for (int i = 0; i < showStr.Length; i++)
{
data[8 + i] = Convert.ToByte(value[i]);
data[8 + i] = Convert.ToByte(showStr[i]);
}
data[14] = 0x00;
return data;
}
/// <summary>
/// 展示字符串
/// </summary>
/// <param name="tagId"></param>
/// <param name="value"></param>
/// <returns></returns>
public static byte[] ShowValue(byte tagId, string? value)
{
string showStr;
if (string.IsNullOrEmpty(value))
{
showStr = "ERR";
}
else
{
showStr = value!.ToString()!;
}
if (showStr!.Length < 6)
{
showStr = showStr.PadLeft(6, '0');
}
else
{
showStr = showStr.Substring(showStr.Length - 6, 6);
}
byte[] data = new byte[15];
data[0] = 0x0f;
data[1] = 0;
data[2] = 0x60;
data[6] = 0x00;
data[7] = tagId;
for (int i = 0; i < showStr.Length; i++)
{
data[8 + i] = Convert.ToByte(showStr[i]);
}
data[14] = 0x00;
return data;

10
WcsMain/PlcOperation/ConnectPLCs.cs → WcsMain/EquipOperation/ConnectPLCs.cs
View File

@ -4,7 +4,7 @@ using WcsMain.DataBase.Dao;
using WcsMain.DataBase.TableEntity;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.PlcOperation;
namespace WcsMain.EquipOperation;
/// <summary>
/// 连接PLC
@ -23,11 +23,17 @@ public class ConnectPLCs(AppPLCDao pLCDao, AppDBDao dBDao)
{
/* 查询所有PLC */
List<AppPLC>? plcs = _plcDao.GetDataWithStatus(1);
if (plcs == default || plcs.Count == 0)
if (plcs == default)
{
ConsoleLog.Tip("$[异常]PLC 数据查找失败，请检查网络是否正常或者是否录入PLC数据");
return true;
}
if (plcs.Count == 0)
{
ConsoleLog.Warning("【警告】您没有录入或者启用任何 PLC");
CommonData.IsConnectPlc = false;
return false;
}
List<AppDB>? dbs = _dbDao.Select();
CommonTool.Siemens = new SiemensS7();
CommonTool.Siemens.SetPlcs(plcs).SetPlcDB(dbs);

8
WcsMain/PlcOperation/ConveyOperation.cs → WcsMain/EquipOperation/Convey/ConveyOperation.cs
View File

@ -1,10 +1,10 @@
using System.Text;
using System.Text.RegularExpressions;
using WcsMain.Common;
using WcsMain.PlcOperation.Entity;
using WcsMain.EquipOperation.Entity;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.PlcOperation;
namespace WcsMain.EquipOperation.Convey;
/// <summary>
/// 输送机操作 ---- 箱式线，不包含于立库库前设备，库前请参考堆垛机操作
@ -90,9 +90,9 @@ public class ConveyOperation
return writeResult.Message ?? "写入失败，未知原因";
}
/// <summary>
/// 获取箱式线出库站台状态
/// </summary>

88
WcsMain/EquipOperation/ElTag/AtopOperation.cs Normal file
View File

@ -0,0 +1,88 @@
using WcsMain.Common;
using WcsMain.ElTag.Atop.AtopEnum;
using WcsMain.ElTag.Atop.Entity;
using WcsMain.Tcp.Entity;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.EquipOperation.ElTag;
[Component]
public class AtopOperation
{
/// <summary>
/// 点亮这个连接中的所有电子标签，并闪烁
/// </summary>
/// <param name="tcpServe"></param>
public void BlinkingAll(TcpServeConnectionData tcpServe)
{
if (CommonData.AppElTags == default || CommonData.AppElTags.Count < 1) return;
var tagInfos = CommonData.AppElTags.FindAll(f => f.ControllerDisplayName == tcpServe.DisplayName);
if (tagInfos == default) return;
/* 使标签闪烁一段时间，告知使用者电子标签已经连上 */
Thread.Sleep(5000);
foreach (var tagInfo in tagInfos)
{
int col = new Random().Next(0, 6);
CommonTool.OprTcpClient.Send(TagSendInfo.ShowTagId(Convert.ToByte(tagInfo.TagId)), tagInfo.ControllerDisplayName!);
CommonTool.OprTcpClient.Send(TagSendInfo.LedColor(Convert.ToByte(tagInfo.TagId), (LedColor)col), tagInfo.ControllerDisplayName!); // 显示颜色
CommonTool.OprTcpClient.Send(TagSendInfo.LedStatus(Convert.ToByte(tagInfo.TagId), LedStatus._0_25secblinking), tagInfo.ControllerDisplayName!); // 显示闪烁频率
}
Thread.Sleep(5000);
foreach (var tagInfo in tagInfos)
{
CommonTool.OprTcpClient.Send(TagSendInfo.TurnOffTag(Convert.ToByte(tagInfo.TagId)), tagInfo.ControllerDisplayName!);
}
}
/// <summary>
/// 向标签发送一个显示值
/// </summary>
/// <param name="controllerDisplayName"></param>
/// <param name="tagId"></param>
/// <param name="value"></param>
/// <param name="ledColor"></param>
/// <param name="ledStatus"></param>
/// <returns></returns>
public Exception? ShowMsg(string? controllerDisplayName, int? tagId, int? value, LedColor ledColor = LedColor.Green, LedStatus ledStatus = LedStatus._0_5secblinking)
{
if (controllerDisplayName == default || tagId == default || value == default)
{
return new Exception("必须的值为空，无法发送电子标签");
}
byte[] elTagData = TagSendInfo.ShowValue(Convert.ToByte(tagId), value);
var sendResult = CommonTool.OprTcpClient.Send(elTagData, controllerDisplayName); // 显示字符
CommonTool.OprTcpClient.Send(TagSendInfo.LedColor(Convert.ToByte(tagId), ledColor), controllerDisplayName); // 显示颜色
CommonTool.OprTcpClient.Send(TagSendInfo.LedStatus(Convert.ToByte(tagId), ledStatus), controllerDisplayName); // 显示闪烁频率
if (sendResult.Success) return default;
return sendResult.Exception;
}
/// <summary>
/// 向标签发送一个显示值
/// </summary>
/// <param name="controllerDisplayName"></param>
/// <param name="tagId"></param>
/// <param name="value"></param>
/// <param name="ledColor"></param>
/// <param name="ledStatus"></param>
/// <returns></returns>
public Exception? ShowMsg(string? controllerDisplayName, int? tagId, string? value, LedColor ledColor = LedColor.Green, LedStatus ledStatus = LedStatus._0_5secblinking)
{
if (controllerDisplayName == default || tagId == default || value == default)
{
return new Exception("必须的值为空，无法发送电子标签");
}
byte[] elTagData = TagSendInfo.ShowValue(Convert.ToByte(tagId), value);
var sendResult = CommonTool.OprTcpClient.Send(elTagData, controllerDisplayName); // 显示字符
CommonTool.OprTcpClient.Send(TagSendInfo.LedColor(Convert.ToByte(tagId), ledColor), controllerDisplayName); // 显示颜色
CommonTool.OprTcpClient.Send(TagSendInfo.LedStatus(Convert.ToByte(tagId), ledStatus), controllerDisplayName); // 显示闪烁频率
if (sendResult.Success) return default;
return sendResult.Exception;
}
}

2
WcsMain/PlcOperation/Entity/ConveyPLCTask.cs → WcsMain/EquipOperation/Entity/ConveyPLCTask.cs
View File

@ -1,4 +1,4 @@
namespace WcsMain.PlcOperation.Entity;
namespace WcsMain.EquipOperation.Entity;
/// <summary>
/// 给输送机任务

4
WcsMain/PlcOperation/Entity/Stacker/StackerInfo.cs → WcsMain/EquipOperation/Entity/Stacker/StackerInfo.cs
View File

@ -1,6 +1,6 @@
using WcsMain.Enum.Stacker;
namespace WcsMain.PlcOperation.Entity.Stacker;
namespace WcsMain.EquipOperation.Entity.Stacker;
/// <summary>
/// 堆垛机信息，读取的时候赋值
@ -23,7 +23,7 @@ public class StackerInfo
/// </summary>
public StackerStatusEnum StackerStatus { get; set; }
/// <summary>
/// 当前巷道

2
WcsMain/PlcOperation/Entity/Stacker/StackerPlcTask.cs → WcsMain/EquipOperation/Entity/Stacker/StackerPlcTask.cs
View File

@ -1,7 +1,7 @@
using System.Collections;
using WcsMain.Enum.TaskEnum;
namespace WcsMain.PlcOperation.Entity.Stacker;
namespace WcsMain.EquipOperation.Entity.Stacker;
/// <summary>
/// 写入PLC的任务 ---- 堆垛机

2
WcsMain/PlcOperation/Entity/StackerConvey/StackerConveyInfo.cs → WcsMain/EquipOperation/Entity/StackerConvey/StackerConveyInfo.cs
View File

@ -1,6 +1,6 @@
using WcsMain.Enum.Plc;
namespace WcsMain.PlcOperation.Entity.StackerConvey;
namespace WcsMain.EquipOperation.Entity.StackerConvey;
/// <summary>
/// 库前输送机反馈的状态信息

2
WcsMain/PlcOperation/Entity/StackerConvey/StackerConveyPlcTask.cs → WcsMain/EquipOperation/Entity/StackerConvey/StackerConveyPlcTask.cs
View File

@ -1,4 +1,4 @@
namespace WcsMain.PlcOperation.Entity.StackerConvey;
namespace WcsMain.EquipOperation.Entity.StackerConvey;
public class StackerConveyPlcTask
{

2
WcsMain/PlcOperation/Entity/StackerFeedbackStatus.cs → WcsMain/EquipOperation/Entity/StackerFeedbackStatus.cs
View File

@ -1,4 +1,4 @@
namespace WcsMain.PlcOperation.Entity;
namespace WcsMain.EquipOperation.Entity;
/// <summary>
/// 堆垛机状态反馈实体

2
WcsMain/PlcOperation/Entity/TaskFeedBackEntity.cs → WcsMain/EquipOperation/Entity/TaskFeedBackEntity.cs
View File

@ -1,4 +1,4 @@
namespace WcsMain.PlcOperation.Entity;
namespace WcsMain.EquipOperation.Entity;
/// <summary>
/// 过账数据实体

16
WcsMain/PlcOperation/Stacker/StackerOperation.cs → WcsMain/EquipOperation/Stacker/StackerOperation.cs
View File

@ -1,11 +1,11 @@
using WcsMain.Common;
using WcsMain.DataBase.TableEntity;
using WcsMain.Enum.Stacker;
using WcsMain.PlcOperation.Entity;
using WcsMain.PlcOperation.Entity.Stacker;
using WcsMain.EquipOperation.Entity;
using WcsMain.EquipOperation.Entity.Stacker;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.PlcOperation.Stacker;
namespace WcsMain.EquipOperation.Stacker;
/// <summary>
/// 堆垛机操作
@ -13,7 +13,7 @@ namespace WcsMain.PlcOperation.Stacker;
[Component]
public class StackerOperation
{
/********************************** 总结方法 *******************************************/
@ -31,15 +31,15 @@ public class StackerOperation
if (stackerId == default) return StackerUseStatusEnum.BusyOrErr;
/* 获取堆垛机状态 */
var (errMsg, stackerInfo) = GetStackerInfo((int)stackerId!);
if(!string.IsNullOrEmpty(errMsg) || stackerInfo == default) return StackerUseStatusEnum.BusyOrErr;
if (!string.IsNullOrEmpty(errMsg) || stackerInfo == default) return StackerUseStatusEnum.BusyOrErr;
/* 堆垛机空闲条件 */
var canUse = stackerInfo.PlcId == 0 && stackerInfo.ControlModel == StackerControlModeEnum.online
var canUse = stackerInfo.PlcId == 0 && stackerInfo.ControlModel == StackerControlModeEnum.online
&& stackerInfo.StackerStatus == StackerStatusEnum.free && stackerInfo.ErrCode == 0;
if (canUse) return StackerUseStatusEnum.Free;
/* 堆垛机等待任务条件（二次申请） */
var waitTask = stackerInfo.ControlModel == StackerControlModeEnum.online && stackerInfo.StackerStatus == StackerStatusEnum.applyTask
&& stackerInfo.ErrCode == 0;
if(waitTask)
if (waitTask)
{
plcId1 = stackerInfo.PlcId;
spare1 = stackerInfo.Spare1;
@ -203,7 +203,7 @@ public class StackerOperation
{
if (!CommonData.IsConnectPlc || CommonTool.Siemens == default) return "PLC尚未连接。"; // 未连接PLC
var dbAddressName = $"堆垛机写任务{task.StackerId}";
if(forkId != 0) { dbAddressName += $"-{forkId}"; }
if (forkId != 0) { dbAddressName += $"-{forkId}"; }
var (writeResult, _) = CommonTool.Siemens.WritePlcWhithName(dbAddressName,
task.PlcId!,
task.TaskType!,

8
WcsMain/PlcOperation/StackerConvey/StackerConveyOperation.cs → WcsMain/EquipOperation/StackerConvey/StackerConveyOperation.cs
View File

@ -1,15 +1,15 @@
using WcsMain.Common;
using WcsMain.Enum.Plc;
using WcsMain.PlcOperation.Entity;
using WcsMain.PlcOperation.Entity.StackerConvey;
using WcsMain.EquipOperation.Entity;
using WcsMain.EquipOperation.Entity.StackerConvey;
using WcsMain.WcsAttribute.AutoFacAttribute;
namespace WcsMain.PlcOperation.StackerConvey;
namespace WcsMain.EquipOperation.StackerConvey;
[Component]
public class StackerConveyOperation
{
/// <summary>
/// 读取输送机状态
/// </summary>

2
WcsMain/ExtendMethod/AppWcsTaskExtendMethod.cs
View File

@ -1,6 +1,6 @@
using WcsMain.DataBase.TableEntity;
using WcsMain.Enum.TaskEnum;
using WcsMain.PlcOperation.Entity.Stacker;
using WcsMain.EquipOperation.Entity.Stacker;
namespace WcsMain.ExtendMethod;

2
WcsMain/StartAction/ServiceStart.cs
View File

@ -1,5 +1,4 @@
using WcsMain.Socket;
using WcsMain.PlcOperation;
using WcsMain.Common;
using WcsMain.WcsAttribute.AutoFacAttribute;
using WcsMain.Plugins;
@ -10,6 +9,7 @@ using WcsMain.DataBase.TableEntity;
using WcsMain.WcsAttribute.AppConfig;
using WcsMain.Business.Convey;
using WcsMain.ElTag.Atop;
using WcsMain.EquipOperation;
namespace WcsMain.StartAction;

13
WcsMain/Tcp/Client/BaseTcpClient.cs
View File

@ -164,9 +164,16 @@ public class BaseTcpClient
checkTasks.Add(Task.Factory.StartNew(() =>
{
// Ping 地址
System.Net.NetworkInformation.Ping ping = new();
var pingResult = ping.Send(tcpServe.TcpServe!.TcpIp!, 100);
if(pingResult.Status != System.Net.NetworkInformation.IPStatus.Success)
bool pingok = false;
for(int i = 0; i < 4; i++)
{
System.Net.NetworkInformation.Ping ping = new();
var pingResult = ping.Send(tcpServe.TcpServe!.TcpIp!, 100);
if (pingResult.Status != System.Net.NetworkInformation.IPStatus.Success) continue;
pingok = true;
break;
}
if(!pingok)
{
tcpServe.TcpClient?.Close();
//tcpServe.IsConnected = Enum.General.TrueFalseEnum.FALSE;