ICM-WCS/wcs
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

液晶标签协议对接 接口业务实现

Browse Source
This commit is contained in:
hehaibing-1996
2024-12-10 16:47:51 +08:00
parent 1c2a34256e
commit c94af9e987
9 changed files with 440 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
WCS.BLL/DbModels/Task/CurrentTask.cs
View File

@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
/// <summary>
/// 当前正在进行中的任务
/// </summary>
[SugarTable("wcs_current_task")]
[SugarTable("wcs_task_current")]
public class CurrentTask
{
/// <summary>
@ -22,6 +22,31 @@ namespace WCS.BLL.DbModels
public int Id { get; set; }
#region 库位属性
/// <summary>
/// 货架Id
/// </summary>
[SugarColumn(ColumnName = "shelf_id", IsNullable = false, ColumnDescription = "货架Id")]
public int ShelfId { get; set; }
/// <summary>
/// 货架号
/// </summary>
[SugarColumn(ColumnName = "shelf_code", Length = 50, IsNullable = false, ColumnDescription = "货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架")]
public string ShelfCode { get; set; }
/// <summary>
/// 模组Id
/// </summary>
[SugarColumn(ColumnName = "module_id", IsNullable = false, ColumnDescription = "模组Id")]
public int ModuleId { get; set; }
/// <summary>
/// 模组编号
/// </summary>
[SugarColumn(ColumnName = "module_code", Length = 50, IsNullable = false, ColumnDescription = "模组编码")]
public string ModuleCode { get; set; }
/// <summary>
/// 入库的库位表ID
/// </summary>

30
WCS.BLL/DbModels/Task/FinishedTask.cs
View File

@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
/// <summary>
/// 已完成未提交的任务
/// </summary>
[SugarTable("wcs_finished_task")]
[SugarTable("wcs_task_finished")]
public class FinishedTask
{
/// <summary>
@ -23,6 +23,29 @@ namespace WCS.BLL.DbModels
#region 库位属性
/// <summary>
/// 货架Id
/// </summary>
[SugarColumn(ColumnName = "shelf_id", IsNullable = false, ColumnDescription = "货架Id")]
public int ShelfId { get; set; }
/// <summary>
/// 货架号
/// </summary>
[SugarColumn(ColumnName = "shelf_code", Length = 50, IsNullable = false, ColumnDescription = "货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架")]
public string ShelfCode { get; set; }
/// <summary>
/// 模组Id
/// </summary>
[SugarColumn(ColumnName = "module_id", IsNullable = false, ColumnDescription = "模组Id")]
public int ModuleId { get; set; }
/// <summary>
/// 模组编号
/// </summary>
[SugarColumn(ColumnName = "module_code", Length = 50, IsNullable = false, ColumnDescription = "模组编码")]
public string ModuleCode { get; set; }
/// <summary>
/// 入库的库位表ID
/// </summary>
[SugarColumn(ColumnName = "store_id", IsNullable = false, ColumnDescription = "库位ID")]
@ -110,11 +133,6 @@ namespace WCS.BLL.DbModels
[SugarColumn(ColumnName = "create_time", IsNullable = false, ColumnDescription = "创建时间")]
public DateTime CreateTime { get; set; } = DateTime.Now;
/// <summary>
/// 创建人
/// </summary>
[SugarColumn(ColumnName = "create_user", Length = 100, IsNullable = true, ColumnDescription = "创建人")]
public string CreateUser { get; set; } = string.Empty;
/// <summary>
/// 完成时物料数量

37
WCS.BLL/DbModels/Task/UploadedTask.cs
View File

@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
/// <summary>
/// 已完成已提交的历史任务
/// </summary>
[SugarTable("wcs_uploaded_task")]
[SugarTable("wcs_task_uploaded")]
public class UploadededTask
{
/// <summary>
@ -22,6 +22,30 @@ namespace WCS.BLL.DbModels
public int Id { get; set; }
#region 库位属性
/// <summary>
/// 货架Id
/// </summary>
[SugarColumn(ColumnName = "shelf_id", IsNullable = false, ColumnDescription = "货架Id")]
public int ShelfId { get; set; }
/// <summary>
/// 货架号
/// </summary>
[SugarColumn(ColumnName = "shelf_code", Length = 50, IsNullable = false, ColumnDescription = "货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架")]
public string ShelfCode { get; set; }
/// <summary>
/// 模组Id
/// </summary>
[SugarColumn(ColumnName = "module_id", IsNullable = false, ColumnDescription = "模组Id")]
public int ModuleId { get; set; }
/// <summary>
/// 模组编号
/// </summary>
[SugarColumn(ColumnName = "module_code", Length = 50, IsNullable = false, ColumnDescription = "模组编码")]
public string ModuleCode { get; set; }
/// <summary>
/// 入库的库位表ID
/// </summary>
@ -110,11 +134,6 @@ namespace WCS.BLL.DbModels
[SugarColumn(ColumnName = "create_time", IsNullable = false, ColumnDescription = "创建时间")]
public DateTime CreateTime { get; set; } = DateTime.Now;
/// <summary>
/// 创建人
/// </summary>
[SugarColumn(ColumnName = "create_user", Length = 100, IsNullable = true, ColumnDescription = "创建人")]
public string CreateUser { get; set; } = string.Empty;
/// <summary>
/// 完成时物料数量
@ -126,6 +145,12 @@ namespace WCS.BLL.DbModels
/// </summary>
[SugarColumn(ColumnName = "finish_time", IsNullable = false, ColumnDescription = "完成时间")]
public DateTime FinishTime { get; set; } = DateTime.Now;
/// <summary>
/// 完成时间
/// </summary>
[SugarColumn(ColumnName = "upload_time", IsNullable = false, ColumnDescription = "上传时间")]
public DateTime UploadTime { get; set; } = DateTime.Now;
#endregion
}
}

413
WCS.BLL/HardWare/MXL4Shelf.cs
View File

@ -1,4 +1,7 @@
using System;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
@ -30,7 +33,7 @@ namespace WCS.BLL.HardWare
WarningLight = new WarningLight() { LightId = shelfInfo.LightId };
//初始化Module
Task.Run(() =>
var task = Task.Run(() =>
{
var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
foreach (var module in modules)
@ -48,6 +51,63 @@ namespace WCS.BLL.HardWare
ModuleIds = MXL4Modules.Select(t => t.BoardId).ToList();
});
//一个货架存在一个线程去刷新数据
Task.Run(async () =>
{
//等待模组加载完毕再开始发送数据进行刷新
Task.WaitAll(task);
while (true)
{
//未完成首次连接时 暂不发送
if (TcpCleint.IsFirstConnected == false)
{
await Task.Delay(2000);
continue;
}
Logs.Write($"[test]");
try
{
//查询是否有需要刷新的
var needRefreshModules = MXL4Modules.Where(t => t.IsNeedRefresh)
.ToList();
foreach (var module in needRefreshModules)
{
//查询当前是否有任务
var currentTasks = DbHelp.db.Queryable<CurrentTask>()
.Where(t => t.ModuleId == module.ModuleId)
.ToList();
//存在入库、出库、盘点等任务
if (currentTasks != null && currentTasks.Count > 0)
{
}
//不存在入库、出库、盘点等任务
else
{
module.SetCurrentMode(Mode.待机模式);
//向上层系统获取数据
//获取成功 有数据 绑定对应数据
//获取成功 无数据
module.StandbyNoInfoDisplay(TcpCleint);
module.IsNeedRefresh = false;//未获取到库存数据 回没有库位显示信息给硬件
//获取失败 跳过此次循环后继续获取
}
}
}
catch (Exception ex)
{
Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
}
await Task.Delay(1000);
}
});
}
public string ShelfTypeName { get; set; }
@ -114,36 +174,34 @@ namespace WCS.BLL.HardWare
public string OutOperateUser { get; set; } = string.Empty;
#region 协议处理
public void Reset()
{
MXL4Modules.ForEach(t => t.Reset(TcpCleint));
}
#region 弃用
void IShelfBase.Warning()
{
}
public void ShelfCheck()
{
}
public void GoInInstore(string? IPAddress)
{
}
public void GoOutInstore()
{
}
/// <summary>
/// 由自检异常等错误导致的 手动操作处理后重新进入出库模式
/// </summary>
/// <param name="ModuleId"></param>
public void GoInOutstoreByWebSocket(int moduleId)
{
}
public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder, string OperateUser)
{
}
public void GoOutOutstore()
{
}
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder stockTakingOrder)
{
}
/// <summary>
/// 确认盘点 Pda进行触发
@ -154,23 +212,8 @@ namespace WCS.BLL.HardWare
}
public void GoOutStocktaking()
{
}
public void Reset()
{
MXL4Modules.ForEach(t => t.Reset(TcpCleint));
}
public void QueryVoltage(int moduleId)
{
}
public void CalibrationSetOffset(int moduleId, int offSet)
{
}
#endregion
public void SetCurrentMode(Mode mode)
{
@ -187,20 +230,10 @@ namespace WCS.BLL.HardWare
}
});
}
void IShelfBase.Warning()
{
}
public void ShelfCheck()
{
}
#endregion
#region 报警灯协议返回处理
public void WarningLightProcess(byte[] data, int boardId, int lightNumber)
public void WarningLightProcess(byte[] data, int boardId)
{
if (data[TcpCleint.PreFixLength + 2] == 0x20 && data[TcpCleint.PreFixLength + 3] == 0x01)
{
@ -232,156 +265,224 @@ namespace WCS.BLL.HardWare
}
#endregion
#region 协议返回处理
public void ProtocolProcess(byte[] data, int boardId, int lightNumber)
#region 液晶标签协议返回处理
public void ProtocolProcess(byte[] data, int boardId)
{
//协议处理 判断功能位
switch (data[TcpCleint.PreFixLength + 2])
{
case 0x01://进入入库模式返回信号
GoInInstoreProcess(data, boardId, lightNumber);
case 0xA4://标签回到待机模式 请求获取显示数据的信号
if (data[TcpCleint.PreFixLength + 3] == 0x02)
GoBackStandbyModeReturnProcess(data, boardId);
break;
case 0x02://退出入库模式返回信号
GoOutInstoreProcess(data, boardId, lightNumber);
case 0xA1://标签返回入库成功信号
if (data[TcpCleint.PreFixLength + 3] == 0x05)
InStoreSuccessProcess(data, boardId);
break;
case 0x03://正常入库信号
InStoreReturnProcess(data);
case 0xA2://标签返回出库成功信号
if (data[TcpCleint.PreFixLength + 3] == 0x04)
OutStoreSuccessProcess(data, boardId);
break;
case 0x04://入库模式中异常信号
InStoreExceptionReturnProcess(data, boardId, lightNumber);
break;
case 0x05://进入出库模式返回信号
GoInOutstoreProcess(data, boardId, lightNumber);
break;
case 0x06://退出出库模式返回信号
GoOutOutstoreProcess(data, boardId, lightNumber);
break;
case 0x07://正常出库返回信号
OutstoreReturnProcess(data, boardId, lightNumber);
break;
case 0x08://出库模式中异常信号
OutstoreExceptionReturnProcess(data, boardId, lightNumber);
break;
case 0x09://进入盘点模式返回信号
GoInStockTakingReturnProcess(data, boardId, lightNumber);
break;
case 0x0A://退出盘点模式返回信号
GoOutStockTakingReturnProcess(data, boardId, lightNumber);
break;
case 0x13://复位的返回信号
ResetReturnProcess(data, boardId, lightNumber);
break;
case 0x17://电压值1
QueryVoltageProcess(data, boardId, lightNumber);
break;
case 0x18://电压值2
QueryVoltageProcess(data, boardId, lightNumber);
break;
case 0x19://电压值3
QueryVoltageProcess(data, boardId, lightNumber);
break;
case 0x0B://自检结果反馈
SelfCheckProcess(data, boardId, lightNumber);
case 0xA3://标签返回盘点成功信号
if (data[TcpCleint.PreFixLength + 3] == 0x03)
StocktakingSuccessProcess(data, boardId);
break;
default:
;
break;
}
}
/// <summary>
/// 进入入库模式返回信号处理
/// 标签回到待机模式
/// </summary>
/// <param name="data"></param>
public void GoInInstoreProcess(byte[] data, int boardId, int lightNumber)
public void GoBackStandbyModeReturnProcess(byte[] data, int boardId)
{
//获取对应的模组
var module = MXL4Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module != null)
{
module.IsNeedRefresh = true;
}
else
{
Logs.Write($"【回到待机模式】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
}
SetCurrentMode(Mode.待机模式);
}
/// <summary>
/// 退出入库模式返回信号处理
/// 标签返回入库成功信号
/// </summary>
/// <param name="data"></param>
public void GoOutInstoreProcess(byte[] data, int boardId, int lightNumber)
public void InStoreSuccessProcess(byte[] data, int boardId)
{
var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];
//获取对应的模组
var module = MXL4Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module != null)
{
//获取对应的任务
var task = DbHelp.db.Queryable<CurrentTask>()
.Where(t => t.ModuleCode == module.ModuleCode)
.Where(t => t.TaskID == taskId)
.First();
if (task != null)
{
var finishedTask = new FinishedTask()
{
ShelfId = task.ShelfId,
ShelfCode = task.ShelfCode,
ModuleId = task.ModuleId,
ModuleCode = task.ModuleCode,
StoreId = task.StoreId,
StoreCode = task.StoreCode,
TaskID = task.TaskID,
Guid = task.Guid,
TaskMode = task.TaskMode,
OrderNumber = task.OrderNumber,
ButtonColor = task.ButtonColor,
MatCode = task.MatCode,
MatName = task.MatName,
MatSpec = task.MatSpec,
MatBatch = task.MatBatch,
MatSN = task.MatSN,
CreateTime = task.CreateTime,
FinishQty = finishQty,
FinishTime = DateTime.Now,
};
DbHelp.db.Insertable(finishedTask).ExecuteCommand();
DbHelp.db.Deleteable(task).ExecuteCommand();
}
else
{
Logs.Write($"【入库成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
}
}
else
{
Logs.Write($"【入库成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
}
}
/// <summary>
/// 正常入库信号
/// 标签返回出库成功信号
/// </summary>
/// <param name="data"></param>
public void InStoreReturnProcess(byte[] data)
public void OutStoreSuccessProcess(byte[] data, int boardId)
{
var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];
//获取对应的模组
var module = MXL4Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module != null)
{
//获取对应的任务
var task = DbHelp.db.Queryable<CurrentTask>()
.Where(t => t.ModuleCode == module.ModuleCode)
.Where(t => t.TaskID == taskId)
.First();
if (task != null)
{
var finishedTask = new FinishedTask()
{
ShelfId = task.ShelfId,
ShelfCode = task.ShelfCode,
ModuleId = task.ModuleId,
ModuleCode = task.ModuleCode,
StoreId = task.StoreId,
StoreCode = task.StoreCode,
TaskID = task.TaskID,
Guid = task.Guid,
TaskMode = task.TaskMode,
OrderNumber = task.OrderNumber,
ButtonColor = task.ButtonColor,
MatCode = task.MatCode,
MatName = task.MatName,
MatSpec = task.MatSpec,
MatBatch = task.MatBatch,
MatSN = task.MatSN,
CreateTime = task.CreateTime,
FinishQty = finishQty,
FinishTime = DateTime.Now,
};
DbHelp.db.Insertable(finishedTask).ExecuteCommand();
DbHelp.db.Deleteable(task).ExecuteCommand();
}
else
{
Logs.Write($"【出库成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
}
}
else
{
Logs.Write($"【出库成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
}
}
/// <summary>
/// 入库模式中异常处理
/// 标签返回盘点成功信号
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void InStoreExceptionReturnProcess(byte[] data, int boardId, int lightNumber)
public void StocktakingSuccessProcess(byte[] data, int boardId)
{
}
var taskId = Convert.ToInt32(data[TcpCleint.PreFixLength + 4]);
var finishQty = (data[TcpCleint.PreFixLength + 5] << 8) + data[TcpCleint.PreFixLength + 6];
/// <summary>
/// 进入出库模式协议返回
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void GoInOutstoreProcess(byte[] data, int boardId, int lightNumber)
{
}
public void OutstoreReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <summary>
/// 退出出库模式返回信号处理
/// </summary>
/// <param name="data"></param>
public void GoOutOutstoreProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <summary>
/// 出库模式中异常处理
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void OutstoreExceptionReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <summary>
/// 进入盘点模式返回信号
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void GoInStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
public void GoOutStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
public void ResetReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
public void QueryVoltageProcess(byte[] data, int boardId, int lightNumber)
{
}
public void SelfCheckProcess(byte[] data, int boardId, int lightNumber)
{
//获取对应的模组
var module = MXL4Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module != null)
{
//获取对应的任务
var task = DbHelp.db.Queryable<CurrentTask>()
.Where(t => t.ModuleCode == module.ModuleCode)
.Where(t => t.TaskID == taskId)
.First();
if (task != null)
{
var finishedTask = new FinishedTask()
{
ShelfId = task.ShelfId,
ShelfCode = task.ShelfCode,
ModuleId = task.ModuleId,
ModuleCode = task.ModuleCode,
StoreId = task.StoreId,
StoreCode = task.StoreCode,
TaskID = task.TaskID,
Guid = task.Guid,
TaskMode = task.TaskMode,
OrderNumber = task.OrderNumber,
ButtonColor = task.ButtonColor,
MatCode = task.MatCode,
MatName = task.MatName,
MatSpec = task.MatSpec,
MatBatch = task.MatBatch,
MatSN = task.MatSN,
CreateTime = task.CreateTime,
FinishQty = finishQty,
FinishTime = DateTime.Now,
};
DbHelp.db.Insertable(finishedTask).ExecuteCommand();
DbHelp.db.Deleteable(task).ExecuteCommand();
}
else
{
Logs.Write($"【盘点成功】货架【{ShelfCode}】通过模组{module.ModuleCode}({boardId}),通过任务id{taskId}未找到对应任务！");
}
}
else
{
Logs.Write($"【盘点成功】货架【{ShelfCode}】通过板子ID【{boardId}】未找到对应模组！");
}
}
#endregion
}

35
WCS.BLL/HardWare/MXL4ShelfModule.cs
View File

@ -59,6 +59,12 @@ namespace WCS.BLL.HardWare
public byte[] GoInOutstoreModeData = { 0xA2, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 待机模式 无库存显示信息
/// </summary>
public byte[] StandbyNoInfoDisplayData = { 0xA4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
#endregion
public int ModuleId { get; set; }
@ -66,6 +72,8 @@ namespace WCS.BLL.HardWare
public int BoardId { get; set; }
public bool IsEnable { get; set; }
public Mode CurrentMode { get; set; }
public bool IsNeedRefresh { get; set; } = true;
/// <summary>
/// 是否已发送自检命令
/// </summary>
@ -73,22 +81,13 @@ namespace WCS.BLL.HardWare
public List<string> CurrentOutSns { get; set; }
public List<string> CurrentStockTakingSns { get; set; }
public void SetCurrentMode()
public void SetCurrentMode(Mode currentMode)
{
CurrentMode = currentMode;
}
#region 液晶标签存在的协议
/// <summary>
/// 进入出库模式
/// </summary>
/// <param name="tcpClient"></param>
public void GoInOutstoreMode(TCPClient tcpClient)
{
tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
}
/// <summary>
/// 复位
/// </summary>
@ -98,6 +97,20 @@ namespace WCS.BLL.HardWare
tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, ResetData));
}
public void StandbyNoInfoDisplay(TCPClient tcpClient)
{
tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, StandbyNoInfoDisplayData));
}
/// <summary>
/// 进入出库模式
/// </summary>
/// <param name="tcpClient"></param>
public void GoInOutstoreMode(TCPClient tcpClient)
{
tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
}
//发送任务ID
public void SendTaskId(int taskID, TCPClient tcpClient)
{

1
WCS.BLL/Manager/DbInit.cs
View File

@ -76,6 +76,7 @@ namespace WCS.BLL.Manager
, typeof(StockTakingOrder), typeof(StockTakingOrderMatDetail), typeof(InOutRecord)
, typeof(DocumentSerialNumber), typeof(OrderLight), typeof(MatInfoLog)
, typeof(AppVersion)
,typeof(CurrentTask),typeof(FinishedTask), typeof(UploadededTask)
);
//DbHelp.db.CodeFirst.InitTables(typeof(ShelfInfo));

75
WCS.BLL/Manager/TCPClientManager.cs
View File

@ -67,49 +67,44 @@ namespace WCS.BLL.Manager
if (tcpCleint.ShelfTypeName == "液晶标签货架")
{
Logs.Write($"【液晶标签货架开始处理接收数据】{BitConverter.ToString(data)}", LogsType.InstructionsProcess);
//Helper.ReturnDataProcess(TcpCleint, data);
Logs.Write($"【液晶标签货架完成处理接收数据】{BitConverter.ToString(data)}", LogsType.InstructionsProcess);
return EasyTask.CompletedTask;
}
for (int index = 0; index < data.Length - TcpCleint.PreFixLength; index++)
{
//协议拆包 通过前缀校验是否为完整数据包
var prefixInData = data.Skip(index).Take(TcpCleint.PreFixLength);
var isEqual = prefixInData.SequenceEqual(TcpCleint.Prefix);
if (isEqual)
for (int index = 0; index < data.Length - TcpCleint.PreFixLength; index++)
{
var dataTemp = data.Skip(index).Take(TcpCleint.PreFixLength + TcpCleint.DataLength).ToArray();
if (dataTemp.Length < TcpCleint.PreFixLength + TcpCleint.DataLength)//拆包后不满足一条指令的长度
//协议拆包 通过前缀校验是否为完整数据包
var prefixInData = data.Skip(index).Take(TcpCleint.PreFixLength);
var isEqual = prefixInData.SequenceEqual(TcpCleint.Prefix);
if (isEqual)
{
continue;
var dataTemp = data.Skip(index).Take(TcpCleint.PreFixLength + TcpCleint.DataLength).ToArray();
if (dataTemp.Length < TcpCleint.PreFixLength + TcpCleint.DataLength)//拆包后不满足一条指令的长度
{
continue;
}
Logs.Write($"【处理单条指令 开始】{BitConverter.ToString(dataTemp)}", LogsType.InstructionsProcess);
//每次循环index会+1 所以这里-1
index += (TcpCleint.PreFixLength + TcpCleint.DataLength - 1);
//获取板子ID
var boardId = (dataTemp[TcpCleint.PreFixLength + 0] << 8) + dataTemp[TcpCleint.PreFixLength + 1];
//报警灯 返回来就修改对应的灯的颜色
if (dataTemp[TcpCleint.PreFixLength + 2] == 0x20)
{
var shelf = ShelfManager.Shelves.Where(t => t.ClientIp == clientIpHost)
.Where(t => t.LightId == boardId)
.FirstOrDefault();
var mxl4Shelf = shelf as MXL4Shelf;
mxl4Shelf?.WarningLightProcess(dataTemp, boardId);
}
//!= 0x20 货架类型协议返回
else
{
var shelf = ShelfManager.Shelves
.Where(t => t.ClientIp == clientIpHost)
.Where(t => t.ModuleIds != null && t.ModuleIds.Contains(boardId))
.FirstOrDefault();
var mxl4Shelf = shelf as MXL4Shelf;
mxl4Shelf?.ProtocolProcess(dataTemp, boardId);
}
Logs.Write($"【处理单条指令 结束】{BitConverter.ToString(dataTemp)}", LogsType.InstructionsProcess);
}
Logs.Write($"【处理单条指令 开始】{BitConverter.ToString(dataTemp)}", LogsType.InstructionsProcess);
index += (TcpCleint.PreFixLength + TcpCleint.DataLength - 1);//每次循环index会+1 所以这里-1
//获取板子ID
var boardId = (dataTemp[TcpCleint.PreFixLength + 0] << 8) + dataTemp[TcpCleint.PreFixLength + 1];
var lightNumber = Convert.ToInt32(dataTemp[TcpCleint.PreFixLength + 3]);
//报警灯 返回来就修改对应的灯的颜色
if (dataTemp[TcpCleint.PreFixLength + 2] == 0x20)
{
var shelf = ShelfManager.Shelves.Where(t => t.ClientIp == clientIpHost)
.Where(t => t.LightId == boardId)
.FirstOrDefault();
var smartShelf = shelf as SmartShelf;
smartShelf?.WarningLightProcess(dataTemp, boardId, lightNumber);
}
//!= 0x20 货架类型协议返回
else
{
var shelf = ShelfManager.Shelves
.Where(t => t.ClientIp == clientIpHost)
.Where(t => t.ModuleIds != null && t.ModuleIds.Contains(boardId))
.FirstOrDefault();
var smartShelf = shelf as SmartShelf;
smartShelf?.ProtocolProcess(dataTemp, boardId, lightNumber);
}
Logs.Write($"【处理单条指令 结束】{BitConverter.ToString(dataTemp)}", LogsType.InstructionsProcess);
}
}
return EasyTask.CompletedTask;

50
WCS.BLL/Services/Service/MXL4Service.cs
View File

@ -2,6 +2,8 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Policy;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
@ -69,6 +71,7 @@ namespace WCS.BLL.Services.Service
Message = $"操作失败：库位【{task.StoreCode}】当前在{task.TaskMode}！",
};
}
var tasks = new List<CurrentTask>();
//生成任务数据
foreach (var orderDetail in request.List)
@ -106,7 +109,7 @@ namespace WCS.BLL.Services.Service
Message = $"操作失败：{ex.Message}"
};
}
//发送任务至各个标签
//发送任务至各个标签 交给后台线程来做
return new ResponseCommon<object>
{
Code = 200,
@ -131,15 +134,15 @@ namespace WCS.BLL.Services.Service
//第一步：校验库位在数据库中是否都存在
var storeCodeList = request.StoreCodes.Distinct()
.ToList();
var stores = DbHelp.db.Queryable<StoreInfo>()
var modules = DbHelp.db.Queryable<ModuleInfo>()
.LeftJoin<ShelfTypeInfo>((si, sti) => si.ShelfTypeId == sti.Id)
.Where((si, sti) => sti.ShelfTypeName == "液晶货架")
.Where((si, sti) => storeCodeList.Contains(si.StoreCode))
.Select((st, sti) => st)
.Where((si, sti) => sti.ShelfTypeName == "液晶标签货架")
.Where((si, sti) => storeCodeList.Contains(si.ModuleCode))
.Select((si, sti) => si)
.ToList();
if (stores.Count < storeCodeList.Count)
if (modules.Count < storeCodeList.Count)
{
var storeCodesInDB = stores.Select(t => t.StoreCode).ToList();
var storeCodesInDB = modules.Select(t => t.ModuleCode).ToList();
storeCodeList.RemoveAll(t => storeCodesInDB.Contains(t));
return new ResponseCommon
{
@ -147,7 +150,38 @@ namespace WCS.BLL.Services.Service
Message = $"操作失败：库位【{string.Join(",", storeCodeList)}】不存在！",
};
}
//向WMS系统获取对应库位最新的库存信息、更新至电子标签
//第二步:获取到对应货架
var shelfs = modules.Select(t => new
{
ShelfId = t.ShelfId,
ModuId = t.Id
})
.GroupBy(t => t.ShelfId)
.Select(g => new
{
ShelfId = g.Key,
ModuIds = g.Select(t => t.ModuId).ToList()
})
.ToList();
//标记对应的模组为需要刷新
foreach (var shelf in shelfs)
{
var shelfInMemory = ShelfManager.Shelves.Where(t => t.ShelfTypeName == "液晶标签货架")
.Where(t => t.ShelfId == shelf.ShelfId)
.FirstOrDefault();
if (shelfInMemory == null)
{
Logs.Write($"[后台APi refreshInventoryRequest]通过{shelf.ShelfId}在内存缓存中查找货架失败！");
continue;
}
//将内存中对应模组置为需要刷新！
var modulesInMemory = shelfInMemory.MXL4Modules.Where(t => shelf.ModuIds.Contains(t.ModuleId))
.ToList();
modulesInMemory.ForEach(t =>
{
t.IsNeedRefresh = true;
});
}
return new ResponseCommon
{
Code = 200,

9
WCS.BLL/Tool/Helper.cs
View File

@ -441,15 +441,6 @@ namespace WCS.BLL.Tool
dataBase[5] = 0xff;
dataBase[6] = 0x00;
dataBase[7] = 0x00;
//byte[] dataBase = new byte[6];
//dataBase[0] = 0xff;
//dataBase[1] = 0x00;
//dataBase[2] = 0x00;
//dataBase[3] = 0x08;
//dataBase[4] = 0x02;
//dataBase[5] = 0x01;
//dataBase[6] = 0x00;
//dataBase[7] = 0x00;
byte[] dataWithCRC = Crc16(dataBase, dataBase.Length, true);
return dataWithCRC;
}