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

增加MXL4模组

Browse Source
This commit is contained in:
hehaibing-1996
2024-12-07 17:52:56 +08:00
parent cfbf6a81c8
commit 375d6971cc
5 changed files with 885 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -42,6 +42,7 @@ namespace WCS.BLL.HardWare
public LightColorEnum LightColor { get; set; } public LightColorEnum LightColor { get; set; }
public List<int> ModuleIds { get; set; } public List<int> ModuleIds { get; set; }
public List<SmartShelfModule> Modules { get; set; } public List<SmartShelfModule> Modules { get; set; }
public List<MXL4ShelfModule> MXL4Modules { get; set; }
public string ClientIp { get; set; } public string ClientIp { get; set; }
/// <summary> /// <summary>
/// 货架当前模式 /// 货架当前模式

389
WCS.BLL/HardWare/MXL4Shelf.cs Normal file
View File

@ -0,0 +1,389 @@
using System;
using WCS.BLL.Config;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
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 WCS.BLL.HardWare.WarningLight;
namespace WCS.BLL.HardWare
{
/// <summary>
/// 智能货架
/// </summary>
public class MXL4Shelf : IShelfBase
{
public MXL4Shelf(ShelfInfo shelfInfo)
{
ShelfId = shelfInfo.Id;
ShelfCode = shelfInfo.ShelfCode;
RowCounts = shelfInfo.Rowcounts;
ColumnCounts = shelfInfo.Columncounts;
SetCurrentMode(Mode.待机模式);
ClientIp = shelfInfo.ClientIp;
LightId = shelfInfo.LightId;
WarningLight = new WarningLight() { LightId = shelfInfo.LightId };
//初始化Module
Task.Run(() =>
{
var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
foreach (var module in modules)
{
MXL4Modules.Add(new MXL4ShelfModule()
{
ModuleId = module.Id,
ModuleCode = module.ModuleCode,
BoardId = module.BoardId,
IsEnable = module.IsEnable,
CurrentMode = module.CurrentMode
});
}
ModulesStr = string.Join(";", MXL4Modules.Select(t => t.ModuleCode));
ModuleIds = MXL4Modules.Select(t => t.BoardId).ToList();
});
}
public int ShelfId { get; set; }
public string ShelfCode { get; set; }
public int RowCounts { get; set; }
public int ColumnCounts { get; set; }
public Mode CurrentMode { get; set; }
public DateTime SetCurrentModeTime { get; set; }
public string ModulesStr { get; set; }//当前货架所有模组的Str
public string GroupName { get; set; }
public List<SmartShelfModule> Modules { get; set; } = new List<SmartShelfModule>();
public List<MXL4ShelfModule> MXL4Modules { get; set; } = new List<MXL4ShelfModule>();
public TCPClient TcpCleint { get { return TCPClientManager.GetTCPClientByIPHost(ClientIp); } }
public int LightId { get; set; }
public LightColorEnum LightColor { get; set; }
public bool IsWarning { get; set; } = false;
public WarningLight WarningLight { get; set; }
public void ClearWarning()
{
if (this.CurrentMode == Mode.入库模式)
{
WarningLight.BlueLight(TcpCleint);
}
else if (this.CurrentMode == Mode.出库模式)
{
WarningLight.GreenLight(TcpCleint);
}
else if (this.CurrentMode == Mode.盘点模式)
{
WarningLight.GreenLight(TcpCleint);
}
else
{
WarningLight.CloseLight(TcpCleint);
}
}
/// <summary>
/// 自检异常、未响应对应模式的异常
/// </summary>
public List<string> ExceptionMessages { get; set; } = new List<string>();
/// <summary>
/// 过程中异常 入库过程中异常/出库过程中异常
/// </summary>
public List<ProcessingExceptionType> ProcessingExceptions { get; set; } = new List<ProcessingExceptionType>();
public string? CurrentCom { get; set; } = string.Empty;
public MatInfoResponse InStoreData { get; set; }
public List<string> CurrentOutStoreMatSNs { get; set; } = new List<string>();
public OutOrder CurrentOutOrder { get; set; }
public string OrderNumber { get; set; }
public StockTakingOrder CurrentStockTakingOrder { get; set; }
public List<int> ModuleIds { get; set; }
public string ClientIp { get; set; }
//websocket通知的前端的IP地址
public string WebSocketIpAddress { get; set; } = "127.0.0.2";
public string OutOperateUser { get; set; } = string.Empty;
#region 协议处理
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进行触发
/// </summary>
public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
{
return false;
}
public void GoOutStocktaking()
{
}
public void Reset()
{
}
public void QueryVoltage(int moduleId)
{
}
public void CalibrationSetOffset(int moduleId, int offSet)
{
}
public void SetCurrentMode(Mode mode)
{
this.CurrentMode = mode;
this.SetCurrentModeTime = DateTime.Now;
Task.Run(() =>
{
var shelf = DbHelp.db.Queryable<ShelfInfo>().Where(t => t.Id == ShelfId).First();
if (shelf != null)
{
shelf.CurrentMode = mode;
shelf.SetCurrentModeTime = SetCurrentModeTime;
DbHelp.db.Updateable(shelf).ExecuteCommand();
}
});
}
void IShelfBase.Warning()
{
}
public void ShelfCheck()
{
}
#endregion
#region 报警灯协议返回处理
public void WarningLightProcess(byte[] data, int boardId, int lightNumber)
{
if (data[TcpCleint.PreFixLength + 2] == 0x20 && data[TcpCleint.PreFixLength + 3] == 0x01)
{
//常亮或关闭 0x00常亮 0x01关闭
if (data[TcpCleint.PreFixLength + 5] == 0x00)
{
LightColor = LightColorEnum.关闭;
Logs.Write($"货架[{ShelfCode}]，灯状态更新为：{LightColor}");
}
else if (data[TcpCleint.PreFixLength + 5] == 0x01)
{
switch (data[7])
{
case 0x01:
LightColor = LightColorEnum.红色;
break;
case 0x02:
LightColor = LightColorEnum.绿色;
break;
case 0x03:
LightColor = LightColorEnum.蓝色;
break;
default:
break;
}
Logs.Write($"货架[{ShelfCode}]，灯状态更新为：{LightColor}");
}
}
}
#endregion
#region 协议返回处理
public void ProtocolProcess(byte[] data, int boardId, int lightNumber)
{
//协议处理 判断功能位
switch (data[TcpCleint.PreFixLength + 2])
{
case 0x01://进入入库模式返回信号
GoInInstoreProcess(data, boardId, lightNumber);
break;
case 0x02://退出入库模式返回信号
GoOutInstoreProcess(data, boardId, lightNumber);
break;
case 0x03://正常入库信号
InStoreReturnProcess(data);
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);
break;
default:
;
break;
}
}
/// <summary>
/// 进入入库模式返回信号处理
/// </summary>
/// <param name="data"></param>
public void GoInInstoreProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <summary>
/// 退出入库模式返回信号处理
/// </summary>
/// <param name="data"></param>
public void GoOutInstoreProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <summary>
/// 正常入库信号
/// </summary>
/// <param name="data"></param>
public void InStoreReturnProcess(byte[] data)
{
}
/// <summary>
/// 入库模式中异常处理
/// </summary>
/// <param name="data"></param>
/// <param name="boardId"></param>
/// <param name="lightNumber"></param>
public void InStoreExceptionReturnProcess(byte[] data, int boardId, int lightNumber)
{
}
/// <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)
{
}
#endregion
}
}

494
WCS.BLL/HardWare/MXL4ShelfModule.cs Normal file
View File

@ -0,0 +1,494 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.Config;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
namespace WCS.BLL.HardWare
{
public class MXL4ShelfModule : IModuleBase
{
#region 协议
/// <summary>
/// 进入入库模式
/// </summary>
public byte[] GoInInstoreData = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 确认入库
/// </summary>
public byte[] ComfirmInstoreData = { 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
public byte[] ComfirmErrInstoreData = { 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 退出入库模式
/// </summary>
public byte[] GoOutInstoreData = { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 自检模式
/// </summary>
public byte[] CheckModeData = { 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 进入出库模式
/// </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>
public byte[] ResetData = { 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 查询当前电压值
/// </summary>
public byte[] VoltageSingleData = { 0x17, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 查询电压偏移值
/// </summary>
public byte[] OffsetSingleData = { 0x18, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 查询电压标准值
/// </summary>
public byte[] StandardSingleData = { 0x19, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 标定
/// </summary>
public byte[] CalibrationData = { 0x0D, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
/// <summary>
/// 设置偏移量 01 F4 = 500
/// </summary>
public byte[] SetOffsetData = { 0x0E, 0x0A, 0x01, 0xF4, 0x00, 0x00, 0x00, 0x00 };
#endregion
public int ModuleId { get; set; }
public string ModuleCode { get; set; }
public int BoardId { get; set; }
public bool IsEnable { get; set; }
public Mode CurrentMode { get; set; }
/// <summary>
/// 是否已发送自检命令
/// </summary>
public bool IsSelfCheck { get; set; } = false;
public List<string> CurrentOutSns { get; set; }
public List<string> CurrentStockTakingSns { get; set; }
public void SetCurrentMode()
{
}
public void GoInInstoreMode(TCPClient tcpClient)
{
if (CurrentMode != Mode.待机模式)
{
//TO DO 退出对应的模式 然后再发送进入入库模式
}
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.ModuleId == ModuleId)
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
char[] data = "0000000000000000".ToCharArray();
//禁用
char[] dataBan = "0000000000000000".ToCharArray();
var boardStoreNumber = storeInfos.Count();
foreach (var storeInfo in storeInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= boardStoreNumber)
{
data[storeInfo.LightNumber - 1] = '1';
//禁用
if (storeInfo.CurrentMatSn == "禁用")
{
dataBan[storeInfo.LightNumber - 1] = '1';
}
}
}
var dataStr = string.Join("", data.Reverse());
var data1 = dataStr.Substring(8, 8);
var data2 = dataStr.Substring(0, 8);
GoInInstoreData[1] = Convert.ToByte(data1, 2);
GoInInstoreData[2] = Convert.ToByte(data2, 2);
//禁用
var dataBanStr = string.Join("", dataBan.Reverse());
var data1Ban = dataBanStr.Substring(8, 8);
var data2Ban = dataBanStr.Substring(0, 8);
GoInInstoreData[6] = Convert.ToByte(data1Ban, 2);
GoInInstoreData[7] = Convert.ToByte(data2Ban, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInInstoreData));
}
public void ComfirmInstore(TCPClient tcpClient)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmInstoreData));
}
public void ComfirmErrInstore(TCPClient tcpClient)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmErrInstoreData));
}
public void GoOutInstoreMode(TCPClient tcpClient)
{
if (CurrentMode == Mode.入库模式)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutInstoreData));
}
else
{
//这里应该是状态异常的 正常不会是这种状态
Reset(tcpClient);
}
}
/// <summary>
/// 复位
/// </summary>
/// <param name="tcpClient"></param>
public void Reset(TCPClient tcpClient)
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ResetData));
}
/// <summary>
/// 自检
/// </summary>
/// <param name="tcpClient"></param>
public void ShelfCheck(TCPClient tcpClient)
{
if (CurrentMode != Mode.待机模式)
{
return;
}
var storeInfos = DbHelp.db.Queryable<StoreInfo>()
.Where(t => t.ModuleId == ModuleId)
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
char[] data = "0000000000000000".ToCharArray();
//禁用功能
char[] dataBan = "0000000000000000".ToCharArray();
var boardStoreNumber = storeInfos.Count();
foreach (var storeInfo in storeInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= boardStoreNumber)
{
data[storeInfo.LightNumber - 1] = '1';
//禁用功能
if (storeInfo.CurrentMatSn == "禁用")
{
dataBan[storeInfo.LightNumber - 1] = '1';
}
}
}
var dataStr = string.Join("", data.Reverse());
var data1 = dataStr.Substring(8, 8);
var data2 = dataStr.Substring(0, 8);
CheckModeData[1] = Convert.ToByte(data1, 2);
CheckModeData[2] = Convert.ToByte(data2, 2);
//禁用功能
var dataBanStr = string.Join("", dataBan.Reverse());
var data1Ban = dataBanStr.Substring(8, 8);
var data2Ban = dataBanStr.Substring(0, 8);
CheckModeData[6] = Convert.ToByte(data1Ban, 2);
CheckModeData[7] = Convert.ToByte(data2Ban, 2);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, CheckModeData));
}
/// <summary>
/// 进入出库模式、亮灯
/// </summary>
/// <param name="tcpClient"></param>
public void GoInOutStoreMode(TCPClient tcpClient, List<string> outSns)
{
Logs.Write($"模组{ModuleCode}，本次亮灯物料{string.Join(",", outSns)}", LogsType.Outstore);
CurrentOutSns = outSns;
var storeInfos = DbHelp.db.Queryable<StoreInfo>().Where(t => t.ModuleId == ModuleId)
.Where(t => t.BoardId == BoardId)
.OrderBy(t => t.LightNumber)
.ToList();
//计算物料在库的库位
char[] data = "0000000000000000".ToCharArray();
//计算禁用的库位
char[] dataBan = "0000000000000000".ToCharArray();
var storeNumber = storeInfos.Count();
foreach (var storeInfo in storeInfos)
{
if (!string.IsNullOrEmpty(storeInfo.CurrentMatSn) && storeInfo.LightNumber > 0 && storeInfo.LightNumber <= storeNumber)
{
data[storeInfo.LightNumber - 1] = '1';
//禁用
if (storeInfo.CurrentMatSn == "禁用")
{
dataBan[storeInfo.LightNumber - 1] = '1';
}
}
}
var dataStr = string.Join("", data.Reverse());
var data1 = dataStr.Substring(8, 8);
var data2 = dataStr.Substring(0, 8);
GoInOutstoreModeData[1] = Convert.ToByte(data1, 2);
GoInOutstoreModeData[2] = Convert.ToByte(data2, 2);
//禁用
var dataBanStr = string.Join("", dataBan.Reverse());
var data1Ban = dataBanStr.Substring(8, 8);
var data2Ban = dataBanStr.Substring(0, 8);
GoInOutstoreModeData[6] = Convert.ToByte(data1Ban, 2);
GoInOutstoreModeData[7] = Convert.ToByte(data2Ban, 2);
//出库位置亮灯
if (outSns != null && outSns.Count > 0)
{
var outStoreInfos = storeInfos.Where(t => outSns.Contains(t.CurrentMatSn))
.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);
GoInOutstoreModeData[3] = Convert.ToByte(data3, 2);
GoInOutstoreModeData[4] = Convert.ToByte(data4, 2);
if (LocalFile.Config.IsSameMatCodeOut)
{
GoInOutstoreModeData[5] = LocalStatic.CurrentOutStoreColor;
}
else
{
GoInOutstoreModeData[5] = 0x02;
}
}
tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
}
public void ComfirmOutstore(TCPClient tcpClient, byte lightNumber)
{
ComfirmOutstoreData[1] = lightNumber;
tcpClient.Send(tcpClient.GenerateMessage(BoardId, ComfirmOutstoreData));
}
/// <summary>
/// 退出出库模式
/// </summary>
/// <param name="tcpClient"></param>
public void GoOutOutStoreMode(TCPClient tcpClient)
{
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.ModuleId == ModuleId)
.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.ModuleId == ModuleId)
.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.ModuleId == ModuleId)
.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));
}
/// <summary>
/// 查询电压值
/// </summary>
/// <param name="tcpClient"></param>
public void QueryVoltage(TCPClient tcpClient)
{
Thread.Sleep(10);
Task.Run(() =>
{
tcpClient.Send(tcpClient.GenerateMessage(BoardId, VoltageSingleData));
Thread.Sleep(50);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, StandardSingleData));
Thread.Sleep(50);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, OffsetSingleData));
});
}
public void CalibrationSetOffset(int offSet, TCPClient tcpClient)
{
var offSetData = BitConverter.GetBytes(unchecked((short)offSet));
// 检查是否需要交换字节
if (BitConverter.IsLittleEndian)
{
// 如果是小端序系统，则交换字节
byte temp = offSetData[0];
offSetData[0] = offSetData[1];
offSetData[1] = temp;
}
SetOffsetData[2] = offSetData[0];
SetOffsetData[3] = offSetData[1];
tcpClient.Send(tcpClient.GenerateMessage(BoardId, CalibrationData));
Thread.Sleep(100);
tcpClient.Send(tcpClient.GenerateMessage(BoardId, SetOffsetData));
}
}
}

2
WCS.BLL/Manager/ShelfManager.cs
View File

@ -54,7 +54,7 @@ namespace WCS.BLL.Manager
GroupName = shelfInDb.GroupName, GroupName = shelfInDb.GroupName,
}; };
case 3: case 3:
return new SmartShelf(shelfInDb) return new MXL4Shelf(shelfInDb)
{ {
ShelfId = shelfInDb.Id, ShelfId = shelfInDb.Id,
ShelfCode = shelfInDb.ShelfCode, ShelfCode = shelfInDb.ShelfCode,

0
WCS.Model/WebSocketModel/SolveWarningRequesr.cs → WCS.Model/WebSocketModel/SolveWarningRequest.cs
View File