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-05-09 09:43:28 +08:00
parent 311a695498
commit cb6090bf0b
43 changed files with 2909 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
WCS.BLL/HardWare/IShelfBase.cs
View File

@ -90,7 +90,13 @@ namespace WCS.BLL.HardWare
/// <summary>
/// 货架进入盘点模式
/// </summary>
public void GoInStocktaking();
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder);
/// <summary>
/// 货架单个确认盘点
/// </summary>
public bool ConfirmStocktakingSingle(int BoardId,int LightNumber);
/// <summary>
/// 货架退出盘点模式

10
WCS.BLL/HardWare/SingleLightShelf.cs
View File

@ -26,6 +26,11 @@ namespace WCS.BLL.HardWare
public List<string> ExceptionMessages { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public bool IsWarning { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
{
throw new NotImplementedException();
}
public void GoInInstore(string IPAdress)
{
throw new NotImplementedException();
@ -41,6 +46,11 @@ namespace WCS.BLL.HardWare
throw new NotImplementedException();
}
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder)
{
throw new NotImplementedException();
}
public void GoOutInstore()
{
throw new NotImplementedException();

755
WCS.BLL/HardWare/SmartShelf.cs
View File

@ -1,20 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using TouchSocket.Sockets;
using WCS.BLL.Config;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.DAL;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel.InOutRecord;
using WCS.Model.ApiModel.OutStore;
using WCS.Model.WebSocketModel;
using static System.Formats.Asn1.AsnWriter;
namespace WCS.BLL.HardWare
{
@ -150,6 +142,7 @@ namespace WCS.BLL.HardWare
public string OrderNumber { get; set; }
public StockTakingOrder CurrentStockTakingOrder { get; set; }
public List<int> ModuleIds { get; set; }
public string ClientIp { get; set; }
@ -224,13 +217,28 @@ namespace WCS.BLL.HardWare
ExceptionMessages.Add($"模组{item.ModuleCode}未进入入库模式！");
}
//通信校验
var messages = notInstoreList.Select(t => $"模组{t.ModuleCode}未进入入库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
IsWarning = true;
WarningLight.WaringLightAlwaysRed(TcpCleint);
}
//没有报警才亮蓝灯
if(!IsWarning)
if (!IsWarning)
WarningLight.BlueLight(TcpCleint);
//绑定当前进入入库PDA/WCS前端的IP
CurrentCom = IPAddress;
@ -295,6 +303,22 @@ namespace WCS.BLL.HardWare
{
ExceptionMessages.Add($"模组{item.ModuleCode}未成功退出入库模式！");
}
var messages = list.Select(t => $"模组{t.ModuleCode}未成功退出入库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
//报警灯熄灭
WarningLight.CloseLight(TcpCleint);
@ -302,43 +326,89 @@ namespace WCS.BLL.HardWare
public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder)
{
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
try
{
Modules.ForEach(t => { t.Reset(TcpCleint); });
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
{
Modules.ForEach(t => { t.Reset(TcpCleint); });
//复位需要点时间间隔才能响应指令
Thread.Sleep(1500);
}
CurrentMode = Mode.出库模式;
//第二步：货架添加需要出的SN 出库的领料单号
//移除货架所有现有待出库的MatSN
CurrentOutStoreMatSNs.Clear();
////添加属于当前货架的物料
CurrentOutStoreMatSNs.AddRange(MatDetails.Select(t => t.MatSN).ToList());
////记录当前出库的发料单
CurrentOutOrder = outOrder;
////第三步：对应的模组进入出库模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
{
var outMatSns = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Select(mat => mat.MatSN)
.ToList();
t.GoInOutStoreMode(TcpCleint, outMatSns);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功进入出库模式 表示进入出库模式成功，跳出循环
var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.出库模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.出库模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未进入出库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
}
CurrentMode = Mode.出库模式;
//第二步：货架添加需要出的SN 出库的领料单号
//移除货架所有现有待出库的MatSN
CurrentOutStoreMatSNs.Clear();
////添加属于当前货架的物料
CurrentOutStoreMatSNs.AddRange(MatDetails.Select(t => t.MatSN).ToList());
////记录当前出库的发料单
CurrentOutOrder = outOrder;
////第三步：对应的模组进入出库模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
catch (Exception e)
{
var outMatSns = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Select(mat => mat.MatSN)
.ToList();
t.GoInOutStoreMode(TcpCleint, outMatSns);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
GoOutOutstore();
throw e;
}
}
public void GoInStocktaking()
{
this.CurrentMode = Mode.盘点模式;
}
public void GoOutOutstore()
{
//找到在出库中的模组
@ -348,13 +418,228 @@ namespace WCS.BLL.HardWare
{
module.GoOutOutStoreMode(TcpCleint);
}
//Task.Run(() =>
//{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功退出出库模式 表示退出出库模式成功，跳出循环
var isExistsOutstore = outingModules.Where(t => t.CurrentMode == Mode.出库模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsOutstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.出库模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未退出出库模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.退出入库未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
//});
CurrentOutStoreMatSNs.Clear();
WarningLight.CloseLight(TcpCleint);
this.CurrentMode = Mode.待机模式;
}
public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder stockTakingOrder)
{
try
{
//第一步：设置货架当前模式
if (CurrentMode != Mode.待机模式)
{
Modules.ForEach(t =>
{
if (CurrentMode != Mode.待机模式)
t.Reset(TcpCleint);
});
//复位需要点时间间隔才能响应指令
Thread.Sleep(1500);
}
CurrentMode = Mode.盘点模式;
//第二步：货架添加 盘点单号 记录当前盘点的发料单
CurrentStockTakingOrder = stockTakingOrder;
//第三步：对应的模组进入盘点模式
var boardIds = MatDetails.Select(t => t.StoreInfo.BoardId)
.Distinct()
.OrderBy(t => t)
.ToList();
var outModules = Modules.Where(t => boardIds.Contains(t.BoardId)).ToList();
outModules.ForEach(t =>
{
var noStockTakings = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Where(t => t.IsStocktaking == false)
.Select(mat => mat.MatSN)
.ToList();
t.GoInStockTakingMode(TcpCleint, noStockTakings);
var stockTakings = MatDetails.Where(mat => mat.StoreInfo.BoardId == t.BoardId)
.Where(t => t.IsStocktaking)
.Select(mat => mat.MatSN)
.ToList();
t.ConfirmStockTaking(TcpCleint, stockTakings);
});
//所有板子亮灯后 亮警示灯
WarningLight.GreenLight(TcpCleint);
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功进入盘点模式 表示进入盘点模式成功，跳出循环
var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.盘点模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.盘点模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未进入盘点模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.进入盘点未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
}
catch (Exception e)
{
GoOutStocktaking();
throw e;
}
}
/// <summary>
/// 确认盘点 Pda进行触发
/// </summary>
public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
{
//寻找对应模组
var module = Modules.Where(t => t.BoardId == BoardId).FirstOrDefault(); ;
if (module == null)
return false;
else
{
module.ConfirmStockTakingSingle(TcpCleint, LightNumber);
//报警灯闪一下
WarningLight.SuccessLightGreenEnd(TcpCleint);
//通知前台刷新
Task.Run(() =>
{
var messageMode = new WebSocketMessageModel()
{
IsWarning = false,
ClientIp = "127.0.0.1",
WarningType = WarningTypeEnum.通知刷新盘点
};
WarningManager.SendWarning(messageMode);
});
return true;
}
}
public void GoOutStocktaking()
{
//找到在盘点中的模组
var stockTakingModules = Modules.Where(t => t.CurrentMode == Mode.盘点模式)
.ToList();
foreach (var module in stockTakingModules)
{
module.GoOutStockTakingMode(TcpCleint);
}
Task.Run(() =>
{
//通信校验
var timeOut = 3000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//所有板子成功退出盘点模式 表示退出盘点模式成功，跳出循环
var isExistsNotInstore = stockTakingModules.Where(t => t.CurrentMode == Mode.盘点模式)
.Where(t => t.IsEnable)
.Any();
if (!isExistsNotInstore)
{
break;
}
//循环延时处理
Thread.Sleep(50);
}
var list = stockTakingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.盘点模式).ToList();
if (list != null && list.Count > 0)
{
var messages = list.Select(t => $"模组{t.ModuleCode}未退出盘点模式！").ToList();
messages.Add("请及时联系技术人员处理！");
var exceptionMessage = string.Join("\r\n", messages);
var warningModel = new WebSocketMessageModel()
{
IsWarning = true,
WarningType = WarningTypeEnum.退出盘点未响应,
StoreId = 0,
StoreCode = "",
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1",
};
WarningManager.SendWarning(warningModel);
}
});
CurrentOutStoreMatSNs.Clear();
WarningLight.CloseLight(TcpCleint);
this.CurrentMode = Mode.待机模式;
}
@ -413,6 +698,12 @@ namespace WCS.BLL.HardWare
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;
@ -508,7 +799,7 @@ namespace WCS.BLL.HardWare
// var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
// if (inventoryDetail != null)
// {
// var inOutRecord = new InOutRecord()
// var inOutRecord = new MatInventoryDetailService()
// {
// StoreCode = storeInfo.StoreCode,
// StoreId = storeInfo.Id,
@ -622,18 +913,17 @@ namespace WCS.BLL.HardWare
/// <param name="data"></param>
public void InStoreReturnProcess(byte[] data)
{
Logs.Write("协议处理5.1");
var boardId = (data[TcpCleint.PreFixLength + 0] << 8) + data[TcpCleint.PreFixLength + 1];
var number = Convert.ToInt32(data[TcpCleint.PreFixLength + 3]);
var storeInfo = DbHelp.db.Queryable<StoreInfo>().Where(t => t.BoardId == boardId
&& t.LightNumber == number).First();
Logs.Write("协议处理5.2");
if (storeInfo == null)
{
//TODO 报错
return;
}
Logs.Write("协议处理5.3");
var module = this.Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module == null)
@ -641,7 +931,7 @@ namespace WCS.BLL.HardWare
//TODO 报错
return;
}
Logs.Write("协议处理5.4");
#region 判断是否扫码获取物料信息
//物料未扫码
if (this.InStoreData == null)
@ -655,7 +945,6 @@ namespace WCS.BLL.HardWare
}
else
{
Logs.Write("协议处理5.5");
var exceptionMessage = storeInfo.StoreCode + "入库过程中存在物料未扫描上架！";
var warningModel = new WebSocketMessageModel()
{
@ -671,7 +960,6 @@ namespace WCS.BLL.HardWare
};
WarningManager.SendWarning(warningModel);
Logs.Write("协议处理5.4");
module.ComfirmErrInstore(TcpCleint);
WarningLight.WaringLightAlwaysRed(TcpCleint);
return;
@ -750,7 +1038,6 @@ namespace WCS.BLL.HardWare
module.ComfirmInstore(TcpCleint);
//报警灯亮绿灯 鸣叫一次提示
WarningLight.SuccessLightBlueEnd(TcpCleint);
//SuccessLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
});
}
catch (Exception ex)
@ -759,7 +1046,6 @@ namespace WCS.BLL.HardWare
Logs.Write($"入库保存数据异常，异常信息为{ex.Message}");
//报警灯报警
WarningLight.WaringLightBlueEnd(TcpCleint);
//WaringLightBlueEnd(shelfStatus.ClientIp, shelfStatus.LightId);
}
}
#endregion
@ -822,7 +1108,6 @@ namespace WCS.BLL.HardWare
{
Logs.Write("协议处理5.4");
var exceptionMessage = storeInfo.StoreCode + "入库过程中存在物料未扫描上架！";
//WebSoceketManager.TrySendMessage("127.0.0.1", exceptionMessage);
var warningModel = new WebSocketMessageModel()
{
WarningType = WarningTypeEnum.入库中未扫描上架,
@ -954,47 +1239,21 @@ namespace WCS.BLL.HardWare
ExceptionMessages.Add($"{storeInfo.StoreCode}物料{storeInfo.CurrentMatSn}丢失,库存数据已删除，请重新扫码后入库");
#endregion
#region 【后台】丢失的数据处理
Task.Run(() =>
#region 不处理、WebSocket通知前台
var exceptionMessage = storeInfo.StoreCode + $"进入出库自检发现物料{storeInfo.CurrentMatSn}丢失，请确认是否删除？";
var warningModel = new WebSocketMessageModel()
{
try
{
DbHelp.db.BeginTran();
//库位表字段清空
storeInfo.CurrentMatSn = string.Empty;
DbHelp.db.Updateable(storeInfo).ExecuteCommand();
//库存表记录删除、插入出入记录
var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.StoreId == storeInfo.Id).First();
if (inventoryDetail != null)
{
var inOutRecord = new InOutRecord()
{
StoreCode = storeInfo.StoreCode,
StoreId = storeInfo.Id,
StoreInfo = storeInfo,
MatSN = inventoryDetail.MatSN,
MatCode = inventoryDetail.MatCode,
MatName = inventoryDetail.MatName,
MatBatch = inventoryDetail.MatBatch,
MatQty = inventoryDetail.MatQty,
MatSpec = inventoryDetail.MatSpec,
MatCustomer = inventoryDetail.MatCustomer,
MatSupplier = inventoryDetail.MatSupplier,
Direction = DirectionEnum.丢失,
};
DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
}
DbHelp.db.CommitTran();
}
catch (Exception e)
{
DbHelp.db.RollbackTran();
}
});
WarningType = WarningTypeEnum.出库自检丢失,
StoreId = storeInfo.Id,
StoreCode = storeInfo.StoreCode,
ModuleId = module.ModuleId,
ModuleCode = module.ModuleCode,
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1"
};
WarningManager.SendWarning(warningModel);
#endregion
WarningLight.WaringLightAlwaysRed(TcpCleint);
@ -1013,6 +1272,23 @@ namespace WCS.BLL.HardWare
#region 缓存记录异常信息
ExceptionMessages.Add($"库位{storeInfo.StoreCode}:存在物料未扫描上架");
#endregion
#region 不处理、WebSocket通知前台
var exceptionMessage = $"进入出库自检发现库位{storeInfo.StoreCode}存在物料未扫描上架，请拿下后点击【确认】消除报警";
var warningModel = new WebSocketMessageModel()
{
WarningType = WarningTypeEnum.出库自检未扫描上架,
StoreId = storeInfo.Id,
StoreCode = storeInfo.StoreCode,
ModuleId = module.ModuleId,
ModuleCode = module.ModuleCode,
ShelfCode = ShelfCode,
ShelfId = ShelfId,
WarningMessage = exceptionMessage,
ClientIp = "127.0.0.1"
};
WarningManager.SendWarning(warningModel);
#endregion
WarningLight.WaringLightAlwaysRed(TcpCleint);
}
else
@ -1029,7 +1305,6 @@ namespace WCS.BLL.HardWare
{
if (CurrentMode != Mode.出库模式)
{
//TO DO 未在出库模式 要报错
Logs.Write($"出库错误：{ShelfCode}该货架模式不是出库模式或盘点模式！");
return;
}
@ -1039,14 +1314,12 @@ namespace WCS.BLL.HardWare
.First();
if (storeInfo == null)
{
//TO DO 报错
return;
}
var module = this.Modules.Where(t => t.BoardId == boardId)
.FirstOrDefault();
if (module == null)
{
//TO DO 报错
return;
}
//当前库位未记录MatSn
@ -1076,12 +1349,14 @@ namespace WCS.BLL.HardWare
WarningLight.WaringLightAlwaysRed(TcpCleint);
return;
}
//获取对应的出库单明细
var orderOrderDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
//获取对应的出库单物料明细
var orderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == CurrentOutOrder.Id)
.Where(t => t.MatSN == inventoryDetail.MatSN)
.ToList();
if (orderOrderDetails == null || orderOrderDetails.Count == 0)
.First();
if (orderMatDetails == null)
{
Logs.Write($"{storeInfo.CurrentMatSn},OrderDetail出库明细信息不存在");
//报警灯报警
@ -1118,18 +1393,28 @@ namespace WCS.BLL.HardWare
//库位表 修改
storeInfo.CurrentMatSn = string.Empty;
//发料单明细表 更新为已出库
orderOrderDetails.ForEach(x =>
//发料单物料明细表 更新为已出库
orderMatDetails.IsSended = true;
//发料需求表增加数量
if (CurrentOutOrder.SyncType == SyncTypeEnum.ByMatCode)
{
x.IsSended = true;
});
//TO DO 发料需求表增加数量
//同步更新发料需求表已发数量
var outOrderDetail = DbHelp.db.Queryable<OutOrderDetail>()
.Where(t => t.Id == orderMatDetails.OutOrderDetailId)
.First();
if (outOrderDetail != null)
{
outOrderDetail.OutQty += orderMatDetails.MatQty;
DbHelp.db.Updateable(outOrderDetail).ExecuteCommand();
}
}
//保存数据
DbHelp.db.Deleteable(inventoryDetail).ExecuteCommand();
DbHelp.db.Insertable(inOutRecord).ExecuteCommand();
DbHelp.db.Updateable(storeInfo).ExecuteCommand();
DbHelp.db.Updateable(orderOrderDetails).ExecuteCommand();
DbHelp.db.Updateable(orderMatDetails).ExecuteCommand();
DbHelp.db.CommitTran();
//报警灯同时亮绿灯并鸣叫一次提示。
@ -1154,104 +1439,115 @@ namespace WCS.BLL.HardWare
CurrentOutStoreMatSNs.RemoveAll(t => t == matSN);//删除本次已出的物料SN
var isExsistOut = CurrentOutStoreMatSNs.Any();
//本批次出库已完成
//本次亮灯的物料已全部取出
if (!isExsistOut)
{
//退出出库模式
GoOutOutstore();
WarningLight.CloseLight(TcpCleint);
var currentPickBillNumber = CurrentOutOrder.OrderNumber;
//OrderNumber = string.Empty;
//更新订单状态
UpdateOutOrderStatus(CurrentOutOrder);
CurrentOutOrder = null;
}
//看是否是分批次出库的情况 分批次亮灯
if (LocalFile.Config.IsSameMatCodeOut)
{
#region 触发下一批次的精准发料
//查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
var isLastShelf = ShelfManager.Shelves
.Where(t => t.OrderNumber == OrderNumber)
.Where(t => t.CurrentMode == Mode.出库模式)
.Any();
if (!isLastShelf)
//退出出库模式
var taskGoOut = Task.Run(() =>
{
Logs.Write($"发料单{OrderNumber}，最后一个出库货架，触发精准发料机制！查询是否还存在待出库物料");
var outOrder = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.OrderNumber == OrderNumber)
.First();
if (outOrder != null)
GoOutOutstore();
});
//看是否是分批次出库的情况 分批次亮灯
Task.Run(async () =>
{
await Task.WhenAll(taskGoOut);
if (LocalFile.Config.IsSameMatCodeOut)
{
var outOrderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == outOrder.Id)
.Where(t => t.IsSended == false)
.Includes(t => t.StoreInfo)
.ToList();
if (outOrderMatDetails != null && outOrderMatDetails.Count > 0)
#region 触发下一批次的物料发料
//查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
var isLastShelf = ShelfManager.Shelves
.Where(t => t.OrderNumber == OrderNumber)
.Where(t => t.CurrentMode == Mode.出库模式)
.Any();
if (!isLastShelf)
{
//存在待出库 然后之前又没亮灯的情况 => 精准发料分批次亮灯
Logs.Write($"发料单{OrderNumber}，还有物料未出！");
var outOrderDetailCount = outOrderMatDetails.GroupBy(t => t.MatCode)
.Select(o => new { count = o.Count(), bb = o })
.Where(o => o.count >= 2)
.OrderByDescending(o => o.count)
.ToList();
//相同物料存在盘数超过2的情况，亮下一个盘数多的物料
if (outOrderDetailCount.Count > 0)
Logs.Write($"发料单{OrderNumber}，最后一个出库货架，触发精准发料机制！查询是否还存在待出库物料");
var outOrder = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.OrderNumber == OrderNumber)
.First();
if (outOrder != null)
{
var matCode = outOrderDetailCount.First().bb.Key;
outOrderMatDetails = outOrderMatDetails.Where(t => t.MatCode == matCode)
.ToList();
Logs.Write($"发料单{OrderNumber}，本次亮灯物料{matCode}！");
var outOrderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == outOrder.Id)
.Where(t => t.IsSended == false)
.Includes(t => t.StoreInfo)
.ToList();
if (outOrderMatDetails != null && outOrderMatDetails.Count > 0)
{
//存在待出库 然后之前又没亮灯的情况 => 继续分批次亮灯
Logs.Write($"发料单{OrderNumber}，还有物料未出！");
var outOrderDetailCount = outOrderMatDetails.GroupBy(t => t.MatCode)
.Select(o => new { count = o.Count(), bb = o })
.Where(o => o.count >= 2)
.OrderByDescending(o => o.count)
.ToList();
//相同物料存在盘数超过2的情况，亮下一个盘数多的物料
if (outOrderDetailCount.Count > 0)
{
var matCode = outOrderDetailCount.First().bb.Key;
outOrderMatDetails = outOrderMatDetails.Where(t => t.MatCode == matCode)
.ToList();
Logs.Write($"发料单{OrderNumber}，本次亮灯物料{matCode}！");
}
//相同物料不存在盘数超过n的情况，剩余物料全部亮灯
else
{
//剩余物料全出
Logs.Write($"发料单{OrderNumber}，剩余物料灯全亮！");
}
var shelfIds = outOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
.ToList();
var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList();
var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
if (otherModeShelfs != null && otherModeShelfs.Count > 0)
{
otherModeShelfs.ForEach(t =>
{
t.Reset();
});
Thread.Sleep(1000);
}
//对应的货架对应位置 进入出库模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, outOrder);
shelf.OrderNumber = outOrder.OrderNumber;
});
}
else
{
Logs.Write($"发料单{OrderNumber}，当前物料已发完！");
}
}
//相同物料不存在盘数超过n的情况，剩余物料全部亮灯
else
{
//剩余物料全出
Logs.Write($"发料单{OrderNumber}，剩余物料灯全亮！");
Logs.Write($"发料单{OrderNumber}，OutOrder为null，肯定是有问题");
}
var shelfIds = outOrderMatDetails.Select(t => t.StoreInfo.ShelfId)
.Distinct()
.ToList();
var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList(); ;
var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
if (otherModeShelfs != null && otherModeShelfs.Count > 0)
{
otherModeShelfs.ForEach(t =>
{
t.Reset();
});
Thread.Sleep(1000);
}
//对应的货架对应位置 进入出库模式 亮灯
shelfs.ForEach(shelf =>
{
var matDetails = outOrderMatDetails.Where(t => t.StoreInfo.ShelfCode == shelf.ShelfCode)
.Distinct()
.ToList();
shelf.GoInOutstore(matDetails, outOrder);
shelf.OrderNumber = outOrder.OrderNumber;
});
}
else
{
Logs.Write($"发料单{OrderNumber}，当前物料已发完！");
}
#endregion
}
else
{
Logs.Write($"发料单{OrderNumber}，OutOrder为null，肯定是有问题");
}
}
#endregion
});
}
}
catch (Exception ex)
{
@ -1262,6 +1558,55 @@ namespace WCS.BLL.HardWare
#endregion
}
public void UpdateOutOrderStatus(OutOrder order)
{
//再去获取一遍Order
order = DbHelp.db.Queryable<OutOrder>()
.Where(t => t.Id == order.Id)
.First();
if (order != null)
{
#region 物料明细表是否已发完
var orderMatDetails = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == order.Id)
.ToList();
var isExistNoSendMat = orderMatDetails.Where(t => t.IsSended == false)
.Any();
if (isExistNoSendMat)
{
order.OrderStatus = OutOrderStatus.部分发料;
}
else
{
order.OrderStatus = OutOrderStatus.全部发料;
order.OutOrderExeStatus = OutOrderExeStatus.发料完成;
}
#endregion
#region 单据明细是否已满足发料需求
if (order.OrderStatus == OutOrderStatus.全部发料 &&
order.SyncType == SyncTypeEnum.ByMatCode)
{
var orderDetails = DbHelp.db.Queryable<OutOrderDetail>()
.Where(t => t.OrderId == order.Id)
.ToList();
var isExistNoSend = orderDetails.Where(t => t.ReqQty > t.OutQty).Any();
if (isExistNoSend)
{
order.OrderStatus = OutOrderStatus.部分发料;
}
else
{
order.OrderStatus = OutOrderStatus.全部发料;
}
}
#endregion
DbHelp.db.Updateable(order).ExecuteCommand();
}
}
/// <summary>
/// 退出出库模式返回信号处理
/// </summary>
@ -1385,6 +1730,37 @@ namespace WCS.BLL.HardWare
}
}
/// <summary>
/// 进入盘点模式返回信号
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void GoInStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
var module = this.Modules.Where(t => t.BoardId == boardId).FirstOrDefault();
if (module == null)
{
return;
}
else
{
module.CurrentMode = Mode.盘点模式;
}
}
public void GoOutStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
{
var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.盘点模式).FirstOrDefault();
if (module == null)
{
return;
}
else
{
module.CurrentMode = Mode.待机模式;
}
}
public void ResetReturnProcess(byte[] data, int boardId, int lightNumber)
{
@ -1398,7 +1774,6 @@ namespace WCS.BLL.HardWare
module.CurrentMode = Mode.待机模式;
}
}
#endregion
}

153
WCS.BLL/HardWare/SmartShelfModule.cs
View File

@ -40,12 +40,32 @@ namespace WCS.BLL.HardWare
/// </summary>
public byte[] GoInOutstoreModeData = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00 };
/// <summary>
/// 确认出库信号
/// </summary>
public byte[] ComfirmOutstoreData = { 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 退出出库模式
/// </summary>
public byte[] GoOutOutstoreModeData = { 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 进入盘点模式
/// 04代表颜色为蓝色色
/// </summary>
public byte[] GoInStockTakingModeData = { 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00 };
/// <summary>
/// 确认盘点
/// 03代表颜色为黄色
/// </summary>
public byte[] ConfirmStockTakingData = { 0x09, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00 };
/// <summary>
/// 退出盘点模式
/// </summary>
public byte[] GoOutStockTakingModeData = { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 复位命令
/// </summary>
@ -58,6 +78,7 @@ namespace WCS.BLL.HardWare
public Mode CurrentMode { get; set; }
public List<string> CurrentOutSns { get; set; }
public List<string> CurrentStockTakingSns { get; set; }
public void SetCurrentMode()
{
@ -204,13 +225,11 @@ namespace WCS.BLL.HardWare
}
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
}
public void ComfirmOutstore(TCPClient tcpClient, byte lightNumber)
{
ComfirmOutstoreData[1] = lightNumber;
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmOutstoreData));
}
/// <summary>
/// 退出出库模式
/// </summary>
@ -219,5 +238,135 @@ namespace WCS.BLL.HardWare
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutOutstoreModeData));
}
/// <summary>
/// 未盘点的物料进入盘点模式、亮灯
/// </summary>
/// <param name="tcpClient"></param>
public void GoInStockTakingMode(TCPClient tcpClient, List<string> stockTakingSns)
{
CurrentStockTakingSns = stockTakingSns;
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
char[] outData = "0000000000000000".ToCharArray();
//盘点位置亮灯
if (stockTakingSns != null && stockTakingSns.Count > 0)
{
var outStoreInfos = storeInfos.Where(t => stockTakingSns.Contains(t.CurrentMatSn))
.ToList();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
GoInStockTakingModeData[2] = Convert.ToByte(data3, 2);
GoInStockTakingModeData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInStockTakingModeData));
}
/// <summary>
/// 已确认过的物料
/// </summary>
/// <param name="tcpClient"></param>
public void ConfirmStockTaking(TCPClient tcpClient, List<string> stockTakingSns)
{
CurrentStockTakingSns = stockTakingSns;
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
char[] outData = "0000000000000000".ToCharArray();
//盘点位置亮灯
if (stockTakingSns != null && stockTakingSns.Count > 0)
{
var outStoreInfos = storeInfos.Where(t => stockTakingSns.Contains(t.CurrentMatSn))
.ToList();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
ConfirmStockTakingData[2] = Convert.ToByte(data3, 2);
ConfirmStockTakingData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ConfirmStockTakingData));
}
/// <summary>
/// 单个确认物料
/// </summary>
/// <param name="tcpClient"></param>
public void ConfirmStockTakingSingle(TCPClient tcpClient, int lightNumber)
{
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
//盘点位置亮灯
var outStoreInfos = storeInfos.Where(t => t.LightNumber == lightNumber)
.ToList();
char[] outData = "0000000000000000".ToCharArray();
foreach (var storeInfo in outStoreInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
outData[storeInfo.LightNumber - 1] = '1';
}
}
var outDataStr = string.Join("", outData.Reverse());
var data3 = outDataStr.Substring(8, 8);
var data4 = outDataStr.Substring(0, 8);
ConfirmStockTakingData[2] = Convert.ToByte(data3, 2);
ConfirmStockTakingData[3] = Convert.ToByte(data4, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ConfirmStockTakingData));
}
/// <summary>
/// 退出盘点模式
/// </summary>
/// <param name="tcpClient"></param>
public void GoOutStockTakingMode(TCPClient tcpClient)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutStockTakingModeData));
}
public void ComfirmStockTaking(TCPClient tcpClient, byte lightNumber)
{
ComfirmOutstoreData[1] = lightNumber;
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmOutstoreData));
}
}
}