看板接口的数据不记录

2.增加物料规格的显示

Encode/Encode.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Encode
+{
+    public static class Encode
+    {
+        public static byte[] GetGb2312(string message)
+        {
+           return Encoding.GetEncoding("gb2312").GetBytes(message);
+        }
+    }
+}

Encode/Encode.csproj

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{F344121D-856D-4E5C-8519-6EADDE98616E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Encode</RootNamespace>
+    <AssemblyName>Encode</AssemblyName>
+    <TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Encode.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Encode/Properties/AssemblyInfo.cs

@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("Encode")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Encode")]
+[assembly: AssemblyCopyright("Copyright ©  2024")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("f344121d-856d-4e5c-8519-6eadde98616e")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

WCS.BLL/Config/JsConfig.cs

@@ -41,6 +41,11 @@ namespace WCS.BLL.Config
         public bool IsResetDBOrTable { get; set; }
 
         public int InstoreTimeOut { get; set; } = 5000;
+
+
+        //是否是钻探分院
+        public bool IsZuantan { get; set; }
+
         #region 盟讯公司后台配置
         public bool IsMx { get; set; }
         /// <summary>

WCS.BLL/Config/LocalStatic.cs

@@ -12,5 +12,7 @@ namespace WCS.BLL.Config
         /// 0x02绿色 0x04蓝色
         /// </summary>
         public static byte CurrentOutStoreColor = 0x02;
+
+        public static string WMSToken = string.Empty;
     }
 }

WCS.BLL/DbModels/ModuleInfo.cs

@@ -4,7 +4,9 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.HardWare;
+using TaskModeEnum = WCS.BLL.DbModels.Task.TaskModeEnum;
 
 namespace WCS.DAL.DbModels
 {
@@ -89,7 +91,7 @@ namespace WCS.DAL.DbModels
         public bool IsEnable { get; set; } = true;
 
         [SugarColumn(ColumnName = "current_mode", IsNullable = true, ColumnDescription = "串联后大货架编码;大货架编码：未串联时是与货架编码是一对一的关系；串联后与货架编码是一对多的关系")]
-        public Mode CurrentMode { get; set; } = Mode.待机模式;
+        public TaskModeEnum CurrentMode { get; set; } = TaskModeEnum.待机模式;
 
         /// <summary>
         /// 序号

WCS.BLL/DbModels/ShelfInfo.cs

@@ -21,7 +21,7 @@ namespace WCS.DAL.DbModels
         /// <summary>
         /// 货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架
         /// </summary>       
-        [SugarColumn(ColumnName = "shelf_code", Length = 50, IsNullable = false, ColumnDescription = "货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架")]
+        [SugarColumn(ColumnName = "shelf_code", Length = 64, IsNullable = false, ColumnDescription = "货架编码;货架一般按照报警灯来区分 一个报警灯指示的是一个货架")]
         public string ShelfCode { get; set; }
 
         /// <summary>
@@ -33,14 +33,14 @@ namespace WCS.DAL.DbModels
         /// <summary>
         /// 货架类型名称
         /// </summary>
-        [SugarColumn(ColumnName = "shelf_type_name", Length = 50, IsNullable = false, ColumnDescription = "货架类型名称")]
+        [SugarColumn(ColumnName = "shelf_type_name", Length = 64, IsNullable = false, ColumnDescription = "货架类型名称")]
         public string ShelfTypeName { get; set; }
 
         /// <summary>
         /// 货架当前状态
         /// </summary>
         [SugarColumn(ColumnName = "current_mode", IsNullable = false, ColumnDescription = "货架当前状态")]
-        public Mode CurrentMode { get; set; }
+        public WCS.BLL.DbModels.Task.TaskModeEnum CurrentMode { get; set; }
 
         /// <summary>
         /// 货架设置当前模式的时间
@@ -49,17 +49,18 @@ namespace WCS.DAL.DbModels
         public DateTime SetCurrentModeTime { get; set; }
 
         /// <summary>
-        /// 货架行数
+        /// 货架行数 对应单灯的第几行
         /// </summary>
         [SugarColumn(ColumnName = "row_counts", IsNullable = false, ColumnDescription = "货架行数")]
-        public int Rowcounts { get; set; }
+        public int Rowcounts { get; set; } 
 
         /// <summary>
-        /// 货架列数
+        /// 货架列数 对应一行有几个
         /// </summary>
         [SugarColumn(ColumnName = "column_counts", IsNullable = false, ColumnDescription = "货架列数")]
         public int Columncounts { get; set; }
 
+
         /// <summary>
         /// 货架对应警示灯的Id
         /// </summary>
@@ -90,13 +91,18 @@ namespace WCS.DAL.DbModels
         [SugarColumn(ColumnName = "group_name", Length = 50, IsNullable = false, ColumnDescription = "货架的组别、区域（区分单个软件管哪些货架的，前端的配置文件配置一个组别，查询时只显示当前组别的货架）")]
         public string GroupName { get; set; }
 
-
         /// <summary>
-        /// 是否串联绑定
+        /// 模块是不是
         /// </summary>
         [SugarColumn(ColumnName = "is_bind", IsNullable = false, ColumnDescription = "是否串联绑定")]
         public bool IsBind { get; set; }
 
+        /// <summary>
+        /// 货架的模块是不是服务端
+        /// </summary>
+        [SugarColumn(ColumnName = "is_service", IsNullable = true, ColumnDescription = "货架的模块是不是服务端")]
+        public bool IsService { get; set; } = false;
+
         /// <summary>
         /// 串联绑定后的大货架编码
         /// </summary>

WCS.BLL/DbModels/StoreInfo.cs

@@ -119,6 +119,31 @@ namespace WCS.DAL.DbModels
         [SugarColumn(ColumnName = "group_name", Length = 50, IsNullable = false, DefaultValue = "0", ColumnDescription = "货架的组别、区域（区分单个软件管哪些货架的，前端的配置文件配置一个组别，查询时只显示当前组别的货架）")]
         public string GroupName { get; set; }
 
+        /// <summary>
+        /// 区域
+        /// </summary>
+        [SugarColumn(ColumnName = "area", Length = 50, IsNullable = false, DefaultValue = "0", ColumnDescription = "货架的区域 用于煤科院按区域灭灯")]
+        public string Area { get; set; }
+
+        /// <summary>
+        /// 单灯每个库位灯的个数
+        /// </summary>
+        [SugarColumn(ColumnName = "single_light_number",  IsNullable = false, DefaultValue = "1", ColumnDescription = "单灯货架灯的个数，用于煤科院大库位灯")]
+        public int SingleLightNumber { get; set; }
+
+
+        /// <summary>
+        /// 灯当前模式
+        /// </summary>
+        [SugarColumn(ColumnName = "light_mode", IsNullable = true, ColumnDescription = "亮灯模式")]
+        public int LightMode { get; set; } = 0;
+
+        /// <summary>
+        /// 灯当前颜色
+        /// </summary>
+        [SugarColumn(ColumnName = "color_mode", IsNullable = true, ColumnDescription = "灯当前颜色")]
+        public int ColorMode { get; set; }= 0;
+
         /// <summary>
         /// 序号
         /// </summary>

WCS.BLL/DbModels/Task/CurrentTask.cs

@@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
     /// <summary>
     /// 当前正在进行中的任务
     /// </summary>
-    [SugarTable("wcs_current_task")]
+    [SugarTable("wcs_task_current")]
     public class CurrentTask
     {
         /// <summary>
@@ -22,20 +22,42 @@ 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>
-        [SugarColumn(ColumnName = "store_id", IsNullable = false, ColumnDescription = "库位ID")]
+        [SugarColumn(ColumnName = "store_id", IsNullable = true, ColumnDescription = "库位ID")]
         public int StoreId { get; set; }
 
         /// <summary>
         /// 入库的库位编码
         /// </summary>
-        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = false, ColumnDescription = "库位编码")]
+        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = true, ColumnDescription = "库位编码")]
         public string StoreCode { get; set; }
-
-        [Navigate(NavigateType.OneToOne, nameof(StoreId))]
-        public StoreInfo StoreInfo { get; set; }
         #endregion
 
         #region 任务属性
@@ -45,6 +67,10 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "task_id", IsNullable = false, ColumnDescription = "任务Id，同一个库位只支持1-7")]
         public int TaskID { get; set; } = 0;
 
+        ///真主键     
+        [SugarColumn(ColumnName = "item_no", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
+        public string ItemNo { get; set; } = string.Empty;
+
         /// <summary>
         /// Guid
         /// </summary>           
@@ -52,7 +78,7 @@ namespace WCS.BLL.DbModels
         public Guid Guid { get; set; }
 
         /// <summary>
-        /// 任务模式：入库模式 = 0, 出库模式 = 1, 盘点模式 = 2
+        /// 任务模式：入库模式 = 1, 出库模式 = 2, 盘点模式 = 3
         /// </summary>
         [SugarColumn(ColumnName = "task_mode", IsNullable = false, ColumnDescription = "任务模式：入库模式 = 0, 出库模式 = 1, 盘点模式 = 2")]
         public TaskModeEnum TaskMode { get; set; }
@@ -60,7 +86,7 @@ namespace WCS.BLL.DbModels
         /// <summary>
         /// 出库单据号
         /// </summary>           
-        [SugarColumn(ColumnName = "order_number", Length = 50, IsNullable = false, ColumnDescription = "出库单据号")]
+        [SugarColumn(ColumnName = "order_number", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
         public string OrderNumber { get; set; }
 
         /// <summary>
@@ -93,6 +119,12 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "mat_batch", Length = 150, IsNullable = true, ColumnDescription = "物料批次")]
         public string MatBatch { get; set; }
 
+        /// <summary>
+        /// 物料SN 物料唯一码
+        /// </summary>           
+        [SugarColumn(ColumnName = "mat_sn", Length = 150, IsNullable = true, ColumnDescription = "物料SN物料唯一码")]
+        public string MatSN { get; set; }
+
         /// <summary>
         /// 物料数量 
         /// </summary>
@@ -111,6 +143,12 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "is_suspended", IsNullable = false, ColumnDescription = "任务是否被挂起 用于入库时取消入库，还没切换库位时 认为任务被挂起")]
         public bool IsSuspended { get; set; } = false;
 
+        /// <summary>
+        /// 任务是否被取消
+        /// </summary>
+        [SugarColumn(ColumnName = "is_cancel", IsNullable = false, ColumnDescription = "任务是否被取消")]
+        public bool IsCancel { get; set; } = false;
+
         /// <summary>
         /// 任务是否已发送至标签
         /// </summary>

WCS.BLL/DbModels/Task/FinishedTask.cs

@@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
     /// <summary>
     /// 已完成未提交的任务
     /// </summary>
-    [SugarTable("wcs_finished_task")]
+    [SugarTable("wcs_task_finished")]
     public class FinishedTask
     {
         /// <summary>
@@ -23,19 +23,39 @@ 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")]
+        [SugarColumn(ColumnName = "store_id", IsNullable = true, ColumnDescription = "库位ID")]
         public int StoreId { get; set; }
 
         /// <summary>
         /// 入库的库位编码
         /// </summary>
-        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = false, ColumnDescription = "库位编码")]
+        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = true, ColumnDescription = "库位编码")]
         public string StoreCode { get; set; }
-
-        [Navigate(NavigateType.OneToOne, nameof(StoreId))]
-        public StoreInfo StoreInfo { get; set; }
         #endregion
 
         #region 任务属性
@@ -45,6 +65,10 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "task_id", IsNullable = false, ColumnDescription = "任务Id，同一个库位只支持1-7")]
         public int TaskID { get; set; }
 
+        ///真主键     
+        [SugarColumn(ColumnName = "item_no", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
+        public string ItemNo { get; set; } = string.Empty;
+
         /// <summary>
         /// Guid
         /// </summary>           
@@ -60,7 +84,7 @@ namespace WCS.BLL.DbModels
         /// <summary>
         /// 出库单据号
         /// </summary>           
-        [SugarColumn(ColumnName = "order_number", Length = 50, IsNullable = false, ColumnDescription = "出库单据号")]
+        [SugarColumn(ColumnName = "order_number", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
         public string OrderNumber { get; set; }
 
         /// <summary>
@@ -92,6 +116,12 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "mat_batch", Length = 150, IsNullable = true, ColumnDescription = "物料批次")]
         public string MatBatch { get; set; }
 
+        /// <summary>
+        /// 物料SN 物料唯一码
+        /// </summary>           
+        [SugarColumn(ColumnName = "mat_sn", Length = 150, IsNullable = true, ColumnDescription = "物料SN物料唯一码")]
+        public string MatSN { get; set; }
+
         /// <summary>
         /// 物料数量 
         /// </summary>
@@ -104,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>
         /// 完成时物料数量 

WCS.BLL/DbModels/Task/UploadedTask.cs

@@ -12,7 +12,7 @@ namespace WCS.BLL.DbModels
     /// <summary>
     /// 已完成已提交的历史任务
     /// </summary>
-    [SugarTable("wcs_uploaded_task")]
+    [SugarTable("wcs_task_uploaded")]
     public class UploadededTask
     {
         /// <summary>
@@ -22,20 +22,41 @@ 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>
-        [SugarColumn(ColumnName = "store_id", IsNullable = false, ColumnDescription = "库位ID")]
+        [SugarColumn(ColumnName = "store_id", IsNullable = true, ColumnDescription = "库位ID")]
         public int StoreId { get; set; }
 
         /// <summary>
         /// 入库的库位编码
         /// </summary>
-        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = false, ColumnDescription = "库位编码")]
+        [SugarColumn(ColumnName = "store_code", Length = 50, IsNullable = true, ColumnDescription = "库位编码")]
         public string StoreCode { get; set; }
-
-        [Navigate(NavigateType.OneToOne, nameof(StoreId))]
-        public StoreInfo StoreInfo { get; set; }
         #endregion
 
         #region 任务属性
@@ -45,6 +66,10 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "task_id", IsNullable = false, ColumnDescription = "任务Id，同一个库位只支持1-7")]
         public int TaskID { get; set; }
 
+        ///真主键     
+        [SugarColumn(ColumnName = "item_no", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
+        public string ItemNo { get; set; } = string.Empty;
+
         /// <summary>
         /// Guid
         /// </summary>           
@@ -60,7 +85,7 @@ namespace WCS.BLL.DbModels
         /// <summary>
         /// 出库单据号
         /// </summary>           
-        [SugarColumn(ColumnName = "order_number", Length = 50, IsNullable = false, ColumnDescription = "出库单据号")]
+        [SugarColumn(ColumnName = "order_number", Length = 128, IsNullable = false, ColumnDescription = "出库单据号")]
         public string OrderNumber { get; set; }
 
         /// <summary>
@@ -92,6 +117,12 @@ namespace WCS.BLL.DbModels
         [SugarColumn(ColumnName = "mat_batch", Length = 150, IsNullable = true, ColumnDescription = "物料批次")]
         public string MatBatch { get; set; }
 
+        /// <summary>
+        /// 物料SN 物料唯一码
+        /// </summary>           
+        [SugarColumn(ColumnName = "mat_sn", Length = 150, IsNullable = true, ColumnDescription = "物料SN物料唯一码")]
+        public string MatSN { get; set; }
+
         /// <summary>
         /// 物料数量 
         /// </summary>
@@ -104,11 +135,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>
         /// 完成时物料数量 
@@ -120,6 +146,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
     }
 }

WCS.BLL/HardWare/IModuleBase.cs

@@ -21,7 +21,7 @@ namespace WCS.BLL.HardWare
         /// <summary>
         /// 当前模式
         /// </summary>
-        Mode CurrentMode { get; set; }
+        WCS.BLL.DbModels.Task.TaskModeEnum CurrentMode { get; set; }
 
         /// <summary>
         /// 设置当前模式

WCS.BLL/HardWare/IShelfBase.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.Model;
 using static WCS.BLL.HardWare.WarningLight;
 
@@ -18,6 +19,11 @@ namespace WCS.BLL.HardWare
         /// 货架是否处于报警中
         /// </summary>
         public bool IsWarning { get; set; }
+        
+        /// <summary>
+        /// 货架类型名称
+        /// </summary>
+        public string ShelfTypeName { get; set; }
         /// <summary>
         /// 货架ID 数据库中那个
         /// </summary>
@@ -42,11 +48,12 @@ namespace WCS.BLL.HardWare
         public LightColorEnum LightColor { get; set; }
         public List<int> ModuleIds { get; set; }
         public List<SmartShelfModule> Modules { get; set; }
+        public List<MXL4ShelfModule> MXL4Modules { get; set; }
         public string ClientIp { get; set; }
         /// <summary>
         /// 货架当前模式
         /// </summary>
-        public Mode CurrentMode { get; set; }
+        public WCS.BLL.DbModels.Task.TaskModeEnum CurrentMode { get; set; }
         /// <summary>
         /// 设置到当前模式的时间
         /// </summary>
@@ -76,7 +83,7 @@ namespace WCS.BLL.HardWare
         /// <summary>
         /// 设置货架模式
         /// </summary>
-        public void SetCurrentMode(Mode mode);
+        public void SetCurrentMode(TaskModeEnum mode);
 
         /// <summary>
         /// 货架进入入库模式
@@ -129,12 +136,4 @@ namespace WCS.BLL.HardWare
         /// </summary>
         public void ShelfCheck();
     }
-
-    public enum Mode
-    {
-        待机模式 = 0,
-        入库模式 = 1,
-        出库模式 = 2,
-        盘点模式 = 3
-    }
 }

WCS.BLL/HardWare/MXL4ShelfModule.cs

@@ -0,0 +1,240 @@
+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.BLL.DbModels.Task;
+using WCS.DAL.Db;
+using WCS.DAL.DbModels;
+
+namespace WCS.BLL.HardWare
+{
+    public class MXL4ShelfModule
+    {
+        #region 协议
+        /// <summary>
+        /// 复位命令
+        /// </summary>
+        public byte[] ResetData = { 0xBE, 0x52, 0x54, 0x41, 0x52, 0x54, 0x0A, 0xED };
+
+        /// <summary>
+        /// 发送任务ID 0x01改为实际发送的任务ID
+        /// </summary>
+        public byte[] SendTaskIdData = { 0xAA, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 发送料号信息
+        /// </summary>
+        public byte[] SendMatCodeData = { 0xA5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 发送名称信息
+        /// </summary>
+        public byte[] SendMatNameData = { 0xA6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 发送规格信息
+        /// </summary>
+        public byte[] SendMatSpecData = { 0xA7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 发送批次信息
+        /// </summary>
+        public byte[] SendMatBatchData = { 0xA8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+
+        /// <summary>
+        /// 发送数量信息
+        /// </summary>
+        public byte[] SendMatQtyData = { 0xA9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 进入入库模式
+        /// </summary>
+        public byte[] GoInInstoreModeData = { 0xA1, 0x01, 0x04, 0x02, 0x40, 0x00, 0x00, 0x00 };
+        /// <summary>
+        /// 退出入库模式
+        /// </summary>
+        public byte[] GoOutInstoreModeData = { 0xA1, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 进入出库模式
+        /// </summary>
+        public byte[] GoInOutstoreModeData = { 0xA2, 0x01, 0x04, 0x02, 0x40, 0x00, 0x00, 0x00 };
+        /// <summary>
+        /// 退出出库模式
+        /// </summary>
+        public byte[] GoOutOutstoreModeData = { 0xA2, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 进入盘点模式
+        /// </summary>
+        public byte[] GoInStocktakingModeData = { 0xA3, 0x01, 0x04, 0x02, 0x40, 0x00, 0x00, 0x00 };
+        /// <summary>
+        /// 进入盘点模式
+        /// </summary>
+        public byte[] GoOutStocktakingModeData = { 0xA3, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 待机模式 无库存显示信息
+        /// </summary>
+        public byte[] StandbyNoInfoDisplayData = { 0xA4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        /// <summary>
+        /// 发送库位编码
+        /// </summary>
+        public byte[] SendStoreCodeData = { 0xBB, 0x00, 0x00, 0x00, 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 TaskModeEnum CurrentMode { get; set; } = TaskModeEnum.待机模式;
+
+        public bool IsNeedRefresh { get; set; } = true;
+
+        public void SetCurrentMode(TaskModeEnum currentMode)
+        {
+            CurrentMode = currentMode;
+        }
+
+
+        #region 液晶标签存在的协议
+        /// <summary>
+        /// 复位
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void Reset(TCPClient tcpClient)
+        {
+            tcpClient.Send(tcpClient.GenerateMessage(BoardId, ResetData));
+
+            Task.Run(() => {
+                if (!IsNeedRefresh)
+                {
+                    Thread.Sleep(2000);
+                    IsNeedRefresh = true;
+                }
+            });
+        }
+
+        public void StandbyNoInfoDisplay(TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, StandbyNoInfoDisplayData));
+        }
+
+        /// <summary>
+        /// 进入入库模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoInInstoreMode(TCPClient tcpClient,ButtonColorEnum buttonColor)
+        {
+            GoInInstoreModeData[2] = (byte)buttonColor;
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoInInstoreModeData));
+            //SetCurrentMode(TaskModeEnum.入库模式);
+        }
+        /// <summary>
+        /// 退出入库模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoOutInstoreMode(TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoOutInstoreModeData));
+            //SetCurrentMode(TaskModeEnum.入库模式);
+        }
+
+        /// <summary>
+        /// 进入出库模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoInOutstoreMode(TCPClient tcpClient, ButtonColorEnum buttonColor)
+        {
+            GoInOutstoreModeData[2] = (byte)buttonColor;
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoInOutstoreModeData));
+            //SetCurrentMode(TaskModeEnum.出库模式);
+        }
+        /// <summary>
+        /// 退出出库模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoOutOutstoreMode(TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoOutInstoreModeData));
+            //SetCurrentMode(TaskModeEnum.出库模式);
+        }
+
+        /// <summary>
+        /// 进入盘点模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoInStocktakingMode(TCPClient tcpClient, ButtonColorEnum buttonColor)
+        {
+            GoInStocktakingModeData[2] = (byte)buttonColor;
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoInStocktakingModeData));
+            //SetCurrentMode(TaskModeEnum.盘点模式);
+        }
+        /// <summary>
+        /// 退出盘点模式
+        /// </summary>
+        /// <param name="tcpClient"></param>
+        public void GoOutStocktakingMode(TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, GoOutStocktakingModeData));
+            //SetCurrentMode(TaskModeEnum.盘点模式);
+        }
+
+        //发送任务ID
+        public void SendTaskId(int taskID, TCPClient tcpClient)
+        {
+            var taskIDData = Convert.ToByte(taskID);
+            SendTaskIdData[1] = taskIDData;
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, SendTaskIdData));
+        }
+        //发送料号
+        public void SendMatCode(string matCode, TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturnList(tcpClient.GenerateMessageList(BoardId, SendMatCodeData, matCode));
+        }
+        //发送名称
+        public void SendMatName(string matName, TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturnList(tcpClient.GenerateMessageList(BoardId, SendMatNameData, matName));
+        }
+        //发送规格
+        public void SendMatSpec(string matSpec, TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturnList(tcpClient.GenerateMessageList(BoardId, SendMatSpecData, matSpec));
+        }
+        //发送批次
+        public void SendMatBatch(string matBatch, TCPClient tcpClient)
+        {
+            tcpClient.SendThenReturnList(tcpClient.GenerateMessageList(BoardId, SendMatBatchData, matBatch));
+        }
+        //发送数量
+        public void SendMatQty(int matQty, TCPClient tcpClient)
+        {
+            var boardIdData = BitConverter.GetBytes(unchecked((short)matQty));
+            // 检查是否需要交换字节  
+            if (BitConverter.IsLittleEndian)
+            {
+                // 如果是小端序系统，则交换字节  
+                byte temp = boardIdData[0];
+                boardIdData[0] = boardIdData[1];
+                boardIdData[1] = temp;
+            }
+            SendMatQtyData[1] = boardIdData[0];
+            SendMatQtyData[2] = boardIdData[1];
+            tcpClient.SendThenReturn(tcpClient.GenerateMessage(BoardId, SendMatQtyData));
+        }
+
+        //发送库位编码
+        public void SendStoreCode(string storeCode, TCPClient tcpClient)
+        {
+            tcpClient.SendList(tcpClient.GenerateMessageList(BoardId, SendStoreCodeData, storeCode));
+        }
+        #endregion
+    }
+}

WCS.BLL/HardWare/SingleLightShelf.cs

@@ -1,35 +1,289 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using TouchSocket.Sockets;
+using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.Manager;
+using WCS.BLL.Tool;
 using WCS.DAL.Db;
 using WCS.DAL.DbModels;
 using WCS.Model;
+using WCS.Model.ApiModel.MKYBackgroundThread;
+using WCS.Model.ApiModel.SingleLight;
 using static WCS.BLL.HardWare.WarningLight;
+using static WCS.BLL.Tool.Helper;
 
 namespace WCS.BLL.HardWare
 {
     public class SingleLightShelf : IShelfBase
     {
-        public SingleLightShelf(ShelfInfo shelfInfo) 
+        public SingleLightShelf(ShelfInfo shelfInfo)
         {
             ShelfId = shelfInfo.Id;
             ShelfCode = shelfInfo.ShelfCode;
             RowCounts = shelfInfo.Rowcounts;
             ColumnCounts = shelfInfo.Columncounts;
-            SetCurrentMode(Mode.待机模式);
+            SetCurrentMode(TaskModeEnum.待机模式);
             ClientIp = shelfInfo.ClientIp;
             LightId = shelfInfo.LightId;
+            IsService = shelfInfo.IsService;
+            ClientIp = shelfInfo.ClientIp;
+
+            if (ClientIp.Contains("127"))
+            {
+                ;
+            }
+
+            ShelfTypeName = shelfInfo.ShelfTypeName;
+
+            //初始化Module
+            Logs.Write($"[初始化单灯货架]初始化模组{ShelfCode}");
+            var task = 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 = TaskModeEnum.待机模式,
+
+                        IsNeedRefresh = false,
+                    });
+                }
+                ModulesStr = string.Join(";", MXL4Modules.Select(t => t.ModuleCode));
+
+                ModuleIds = MXL4Modules.Select(t => t.BoardId).ToList();
+            });
+
+            Logs.Write($"[初始化单灯货架]初始化单灯线程{ShelfCode}");
+            //初始化单灯线程
+            //一个货架存在一个线程去刷新数据
+            Task.Run(async () =>
+            {
+                //等待模组加载完毕再开始发送数据进行刷新
+                Task.WaitAll(task);
+                while (true)
+                {
+                    try
+                    {
+                        await Task.Delay(200);
+                        //未完成首次连接时 暂不发送
+                        if (IsService)
+                        {
+                            if (TcpCleint == null)
+                            {
+                                await Task.Delay(2000);
+                                continue;
+                            }
+                            if (TcpCleint.IsFirstConnected == false)
+                            {
+                                await Task.Delay(2000);
+                                continue;
+                            }
+                        }
+                        else
+                        {
+                            if (ClientIp.Contains("127"))
+                            {
+                                ;
+                            }
+                            var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == ClientIp).FirstOrDefault();
+                            if (tcpClient == null)
+                            {
+                                await Task.Delay(2000);
+                                continue;
+                            }
+                        }
+
+                        //查询属于本货架的任务
+                        var currentShelfTasks = DbHelp.db.Queryable<CurrentTask>()
+                                                         .Where(t => t.ShelfId == this.ShelfId)
+                                                         .Where(t => t.IsSended == false || t.IsCancel == true)
+                                                         .OrderBy(t => t.CreateTime)
+                                                         .ToList();
+
+                        //获取因为任务需要刷新的module
+                        var haveTaskModules = currentShelfTasks.Where(t => t.IsCancel == true || t.IsSended == false)
+                                                               .Select(t => t.ModuleId)
+                                                               .Distinct()
+                                                               .ToList();
+                        MXL4Modules.ForEach(t =>
+                        {
+                            if (haveTaskModules.Contains(t.ModuleId))
+                            {
+                                t.IsNeedRefresh = true;
+                            }
+                        });
+
+                        //查询是否有需要刷新的
+                        var needRefreshModules = MXL4Modules.Where(t => t.IsNeedRefresh)
+                                                            .ToList();
+                        foreach (var module in needRefreshModules)
+                        {
+                            Logs.Write($"[初始化单灯货架]存在需要刷新的{ShelfCode}");
+                            try
+                            {
+                                //查询当前是否有任务
+                                var currentTasks = currentShelfTasks.Where(t => t.ModuleId == module.ModuleId)
+                                                                    .OrderBy(t => t.CreateTime)
+                                                                    .ToList();
+                                #region 取消任务的逻辑 存在取消的任务 先删除任务
+                                var cancelTasks = currentTasks.Where(t => t.IsCancel == true)
+                                                                   .ToList();
+                                if (cancelTasks != null && cancelTasks.Count > 0)
+                                {
+                                    Logs.Write($"[单灯后台刷新线程]当前有任务需要取消！");
+                                    //获取该库位还有无任务
+                                    var currentModuleTask = DbHelp.db.Queryable<CurrentTask>()
+                                                         .Where(t => t.ShelfId == this.ShelfId)
+                                                         .Where(t => t.ModuleId == module.ModuleId)
+                                                         .Where(t => t.IsSended == true && t.IsCancel == false)
+                                                         .ToList();
+                                    //当前库位无任务 关闭库位灯
+                                    if (!currentModuleTask.Any())
+                                    {
+                                        Logs.Write($"[单灯后台刷新线程]当前库位{module.ModuleCode},无任务，关闭库位灯！");
+
+                                        var storeCodes = new List<string>();
+                                        storeCodes.Add(module.ModuleCode);
+                                        var shelfModel = new SingleLightShelfModel();
+                                        //先不操作报警灯
+                                        shelfModel.WarningLightMode = -1;
+                                        shelfModel.WarningLightColor = 0;
+                                        shelfModel.WarningBoardId = 0;
+
+                                        shelfModel.ClientIp = ClientIp;
+                                        shelfModel.StoreList = new List<SingleLightStoreModel>();
+                                        shelfModel.StoreList.Add(new SingleLightStoreModel()
+                                        {
+                                            BoardId = module.BoardId,
+                                            LightColor = 0,
+                                            LightMode = 0,
+                                        });
+                                        var response = SingleLightControl(shelfModel, storeCodes);
+                                        if (response != null && response.Code == 200)
+                                        {
+                                            //删除取消的这个任务
+                                            DbHelp.db.Deleteable(cancelTasks).ExecuteCommand();
+                                            //删除被取消的任务
+                                            await Task.Delay(20);
+                                            module.IsNeedRefresh = false;
+
+
+                                        }
+                                    }
+                                    else
+                                    {
+                                        Logs.Write($"[单灯后台刷新线程]当前库位{module.ModuleCode},还存在任务，不关闭库位灯！");
+
+                                        module.IsNeedRefresh = false;
+                                        continue;
+                                    }
+                                }
+                                #endregion
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
+                            }
+
+                        }
+
+                        //刷新报警灯
+                        if (needRefreshModules != null && needRefreshModules.Count > 0)
+                        {
+                            var currentTasks = DbHelp.db.Queryable<CurrentTask>()
+                                                         .Where(t => t.ShelfId == this.ShelfId)
+                                                         .ToList();
+                            if (currentTasks != null && currentTasks.Count > 0)
+                            {
+                                var firstCurrentTask = currentTasks[0];
+                                //开报警灯 开大灯
+                                var moduleCodes = currentTasks.Select(t => t.ModuleCode)
+                                                              .Distinct()
+                                                              .ToList();
+                                var shelfModel = new SingleLightShelfModel();
+                                //报警灯长亮
+                                shelfModel.WarningLightMode = 1;
+                                shelfModel.WarningLightColor = (int)firstCurrentTask.ButtonColor;
+                                shelfModel.WarningBoardId = shelfInfo.LightId;
+                                shelfModel.ClientIp = ClientIp;
+                                shelfModel.StoreList = new List<SingleLightStoreModel>();
+
+                                Logs.Write($"[单灯后台刷新线程]亮灯任务数量{currentTasks.Count}！");
+                                currentTasks.ForEach(task =>
+                                {
+                                    Logs.Write($"[单灯后台刷新线程]亮灯任务{task.ModuleCode}！");
+                                    var module = MXL4Modules.Where(t => t.ModuleCode == task.ModuleCode).First();
+                                    if (module != null)
+                                    {
+                                        shelfModel.StoreList.Add(new SingleLightStoreModel()
+                                        {
+                                            BoardId = module.BoardId,
+                                            LightColor = (int)task.ButtonColor,
+                                            LightMode = 1,
+                                        });
+                                    }
+                                });
+
+                                var response = SingleLightControl(shelfModel, moduleCodes);
+                                //亮了灯的更新为已发送
+                                if (response != null && response.Code == 200)
+                                {
+                                    Logs.Write($"[单灯后台刷新线程]当前灯继续亮！");
+
+                                    MXL4Modules.ForEach(t => t.IsNeedRefresh = false);
+                                    currentTasks.ForEach(t => t.IsSended = true);
+                                    DbHelp.db.Updateable(currentTasks).UpdateColumns(ct => new { ct.IsSended }).ExecuteCommand();
+                                }
+                            }
+                            else
+                            {
+                                //关报警灯 小灯也全关
+                                var shelfModel = new SingleLightShelfModel();
+                                //报警灯关闭
+                                shelfModel.WarningLightMode = 0;
+                                shelfModel.WarningLightColor = 0;
+                                shelfModel.WarningBoardId = shelfInfo.LightId;
+                                shelfModel.ClientIp = ClientIp;
+                                shelfModel.StoreList = new List<SingleLightStoreModel>();
+                                var response = SingleLightControl(shelfModel, new List<string>());
+                                if (response != null && response.Code == 200)
+                                {
+                                    Logs.Write($"[单灯后台刷新线程]当前灯不继续亮！");
+                                    MXL4Modules.ForEach(t => t.IsNeedRefresh = false);
+                                }
+                            }
+                        }
+
+                    }
+                    catch (Exception ex)
+                    {
+                        Logs.Write($"【后台发送线程】遇到异常{ex.Message},{ex.StackTrace}");
+                    }
+                    await Task.Delay(1500);
+                }
+            });
         }
 
+        public bool IsService { get; set; }
+
+        public string ShelfTypeName { get; set; }
         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 TaskModeEnum CurrentMode { get; set; }
         public string ModulesStr { get; set; }
         public string GroupName { get; set; }
         public MatInfoResponse InStoreData { get; set; }
@@ -48,6 +302,9 @@ namespace WCS.BLL.HardWare
 
         public TCPClient TcpCleint { get { return TCPClientManager.GetTCPClientByIPHost(ClientIp); } }
 
+        public List<MXL4ShelfModule> MXL4Modules { get; set; } = new List<MXL4ShelfModule>();
+
+
         public bool ConfirmStocktakingSingle(int BoardId, int LightNumber)
         {
             throw new NotImplementedException();
@@ -61,33 +318,33 @@ namespace WCS.BLL.HardWare
 
         public void GoInOutstore(List<OutOrderMatDetail> MatDetails, OutOrder outOrder, string OperateUser)
         {
-           
+
         }
 
         public void GoInStocktaking()
         {
-            
+
         }
 
         public void GoInStocktaking(List<StockTakingOrderMatDetail> MatDetails, StockTakingOrder outOrder)
         {
-           
+
         }
 
         public void GoOutInstore()
         {
             //找到已亮灯的 灭灯
-           
+
         }
 
         public void GoOutOutstore()
         {
-            
+
         }
 
         public void GoOutStocktaking()
         {
-            
+
         }
 
         public void Reset()
@@ -95,19 +352,142 @@ namespace WCS.BLL.HardWare
             return;
         }
 
-        public void SetCurrentMode(Mode mode)
+        public void SetCurrentMode(TaskModeEnum mode)
         {
-            
+
         }
 
         public void ShelfCheck()
         {
-           
+
         }
 
         public void Warning()
         {
-          
+
+        }
+
+
+        public ResponseCommon<object> SingleLightControl(SingleLightShelfModel request, List<string> storeCodes)
+        {
+            try
+            {
+                var shelf = DbHelp.db.Queryable<ShelfInfo>().Where(t => t.Id == ShelfId)
+                                                            .First();
+                var client = new
+                {
+                    ClientIp = shelf.ClientIp,
+                    IsService = shelf.IsService,
+                };
+
+                List<SingleLightShelfModel> singleLightShelfModels = new List<SingleLightShelfModel>();
+                singleLightShelfModels.Add(request);
+
+                var sendData = Helper.SingleLightControl(singleLightShelfModels);
+                if (client.IsService)
+                {
+                    TCPClient tcpClient = TCPClientManager.GetTCPClientByIPHost(client.ClientIp);
+                    if (tcpClient != null)
+                    {
+                        try
+                        {
+                            tcpClient.Send(sendData);
+                            Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
+                        }
+                        catch (Exception ex)
+                        {
+                            Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+                        }
+                    }
+                    else
+                    {
+                        Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                    }
+                }
+                else
+                {
+                    var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == ClientIp).FirstOrDefault();
+                    if (tcpClient != null)
+                    {
+                        lock (tcpClient)
+                        {
+                            try
+                            {
+                                tcpClient.Send(sendData, 0, sendData.Length);
+                                Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+                                return new ResponseCommon<object>()
+                                {
+                                    Code = 201,
+                                    Message = $"【单灯单独控制】{client}指令发送中遇到异常{ex.Message}",
+                                };
+                            }
+                            Thread.Sleep(100);
+                        }
+                    }
+                    else
+                    {
+                        Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                        return new ResponseCommon<object>()
+                        {
+                            Code = 201,
+                            Message = $"【单灯单独控制】{client}未连接，以下指令未能成功发送",
+                        };
+                    }
+                }
+
+                var stores = DbHelp.db.Queryable<StoreInfo>()
+                                      .Where(t => storeCodes.Contains(t.StoreCode))
+                                      .ToList();
+                //更新数据库灯的状态
+                stores.ForEach(t =>
+                {
+                    t.LightMode = request.WarningLightMode == -1 ? 0 : request.WarningLightMode;
+                    t.ColorMode = request.WarningLightColor;
+                });
+                DbHelp.db.Updateable(stores)
+                         .UpdateColumns(t => new { t.LightMode, t.ColorMode })
+                         .ExecuteCommand();
+
+                //返回成功
+                return new ResponseCommon<object>()
+                {
+                    Code = 200,
+                    Message = "success",
+                };
+            }
+            catch (Exception ex)
+            {
+
+                //操作失败
+                return new ResponseCommon<object>()
+                {
+                    Code = 300,
+                    Message = $"操作失败：{ex.Message}",
+                };
+            }
+        }
+
+        public string ExtractUntilSecondDashCorrect(string input)
+        {
+            int firstDashIndex = input.IndexOf('-');
+            if (firstDashIndex == -1)
+            {
+                return string.Empty; // 如果没有找到第一个'-'，则返回空字符串
+            }
+
+            int secondDashIndex = input.IndexOf('-', firstDashIndex + 1);
+            if (secondDashIndex == -1)
+            {
+                return input;
+            }
+            else
+            {
+                return input.Substring(0, secondDashIndex);
+            }
         }
     }
 }

WCS.BLL/HardWare/SmartShelf.cs

@@ -1,6 +1,7 @@
 using System;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.Manager;
 using WCS.DAL.Db;
 using WCS.DAL.DbModels;
@@ -23,30 +24,31 @@ namespace WCS.BLL.HardWare
             ShelfCode = shelfInfo.ShelfCode;
             RowCounts = shelfInfo.Rowcounts;
             ColumnCounts = shelfInfo.Columncounts;
-            SetCurrentMode(Mode.待机模式);
+            SetCurrentMode(TaskModeEnum.待机模式);
             ClientIp = shelfInfo.ClientIp;
             LightId = shelfInfo.LightId;
             WarningLight = new WarningLight() { LightId = shelfInfo.LightId };
+            ShelfTypeName = shelfInfo.ShelfTypeName;
 
             //初始化Module
             Task.Run(() =>
-             {
-                 var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
-                 foreach (var module in modules)
                  {
-                     Modules.Add(new SmartShelfModule()
+                     var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => t.ShelfId == ShelfId).ToList();
+                     foreach (var module in modules)
                      {
-                         ModuleId = module.Id,
-                         ModuleCode = module.ModuleCode,
-                         BoardId = module.BoardId,
-                         IsEnable = module.IsEnable,
-                         CurrentMode = module.CurrentMode
-                     });
-                 }
-                 ModulesStr = string.Join(";", Modules.Select(t => t.ModuleCode));
+                         Modules.Add(new SmartShelfModule()
+                         {
+                             ModuleId = module.Id,
+                             ModuleCode = module.ModuleCode,
+                             BoardId = module.BoardId,
+                             IsEnable = module.IsEnable,
+                             CurrentMode = module.CurrentMode
+                         });
+                     }
+                     ModulesStr = string.Join(";", Modules.Select(t => t.ModuleCode));
 
-                 ModuleIds = Modules.Select(t => t.BoardId).ToList();
-             });
+                     ModuleIds = Modules.Select(t => t.BoardId).ToList();
+                 });
         }
 
 
@@ -54,7 +56,7 @@ namespace WCS.BLL.HardWare
         public string ShelfCode { get; set; }
         public int RowCounts { get; set; }
         public int ColumnCounts { get; set; }
-        public Mode CurrentMode { get; set; }
+        public TaskModeEnum CurrentMode { get; set; }
 
         public DateTime SetCurrentModeTime { get; set; }
         public string ModulesStr { get; set; }//当前货架所有模组的Str
@@ -69,15 +71,15 @@ namespace WCS.BLL.HardWare
         public WarningLight WarningLight { get; set; }
         public void ClearWarning()
         {
-            if (this.CurrentMode == Mode.入库模式)
+            if (this.CurrentMode == TaskModeEnum.入库模式)
             {
                 WarningLight.BlueLight(TcpCleint);
             }
-            else if (this.CurrentMode == Mode.出库模式)
+            else if (this.CurrentMode == TaskModeEnum.出库模式)
             {
                 WarningLight.GreenLight(TcpCleint);
             }
-            else if (this.CurrentMode == Mode.盘点模式)
+            else if (this.CurrentMode == TaskModeEnum.盘点模式)
             {
                 WarningLight.GreenLight(TcpCleint);
             }
@@ -113,26 +115,29 @@ namespace WCS.BLL.HardWare
         public string WebSocketIpAddress { get; set; } = "127.0.0.2";
 
         public string OutOperateUser { get; set; } = string.Empty;
+        public List<MXL4ShelfModule> MXL4Modules { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public string ShelfTypeName { get; set; }
+
         #region 协议处理
         public void GoInInstore(string? IPAddress)
         {
             try
             {
                 Logs.Write($"[GoInInstore IPAddress]{IPAddress}", LogsType.Instore);
-                if (this.CurrentMode == Mode.入库模式)
+                if (this.CurrentMode == TaskModeEnum.入库模式)
                 {
                     CurrentCom = IPAddress;
                     return;
                 }
                 //判断当前模式是否为待机模式
-                else if (this.CurrentMode != Mode.待机模式)
+                else if (this.CurrentMode != TaskModeEnum.待机模式)
                 {
                     return;
                 }
                 else
                 {
-                    //this.CurrentMode = Mode.入库模式;
-                    SetCurrentMode(Mode.入库模式);
+                    //this.CurrentMode = TaskModeEnum.入库模式;
+                    SetCurrentMode(TaskModeEnum.入库模式);
                 }
                 //清空错误
                 ExceptionMessages.Clear();
@@ -157,7 +162,7 @@ namespace WCS.BLL.HardWare
                     timeSpan = DateTime.Now - beginTime;
 
                     //所有板子成功进入入库模式 表示进入入库模式成功，跳出循环
-                    var isExistsNotInstore = Modules.Where(t => t.CurrentMode != Mode.入库模式)
+                    var isExistsNotInstore = Modules.Where(t => t.CurrentMode != TaskModeEnum.入库模式)
                                                     .Where(t => t.IsEnable)
                                                     .Any();
                     if (!isExistsNotInstore)
@@ -180,7 +185,7 @@ namespace WCS.BLL.HardWare
                 }
 
                 //循环结束后判断当前板子状态
-                var notInstoreList = Modules.Where(t => t.CurrentMode != Mode.入库模式)
+                var notInstoreList = Modules.Where(t => t.CurrentMode != TaskModeEnum.入库模式)
                                                 .Where(t => t.IsEnable).ToList();
 
                 if (notInstoreList.Count > 0)
@@ -231,14 +236,14 @@ namespace WCS.BLL.HardWare
         public void GoOutInstore()
         {
             //当前货架是否为入库模式
-            if (CurrentMode != Mode.入库模式)
+            if (CurrentMode != TaskModeEnum.入库模式)
             {
                 return;
             }
             else
             {
-                //this.CurrentMode = Mode.待机模式;
-                SetCurrentMode(Mode.待机模式);
+                //this.CurrentMode = TaskModeEnum.待机模式;
+                SetCurrentMode(TaskModeEnum.待机模式);
             }
 
             //清空错误
@@ -247,7 +252,7 @@ namespace WCS.BLL.HardWare
             foreach (var module in Modules.Where(t => t.IsEnable)
                                           .ToList())
             {
-                if (module.CurrentMode == Mode.入库模式)
+                if (module.CurrentMode == TaskModeEnum.入库模式)
                     module.GoOutInstoreMode(TcpCleint);
             }
 
@@ -258,7 +263,7 @@ namespace WCS.BLL.HardWare
             {
                 timeSpan = DateTime.Now - beginTime;
                 //所有板子是否成功退出入库模式
-                var isExistsInstore = Modules.Where(t => t.CurrentMode != Mode.待机模式)
+                var isExistsInstore = Modules.Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                              .Where(t => t.IsEnable)
                                              .Any();
                 if (!isExistsInstore)
@@ -270,13 +275,13 @@ namespace WCS.BLL.HardWare
             }
 
             //循环结束后判断当前板子状态
-            var list = Modules.Where(t => t.CurrentMode != Mode.待机模式)
+            var list = Modules.Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                         .Where(t => t.IsEnable)
                                         .ToList();
             if (list.Count > 0)
             {
-                //CurrentMode = Mode.待机模式;
-                SetCurrentMode(Mode.待机模式);
+                //CurrentMode = TaskModeEnum.待机模式;
+                SetCurrentMode(TaskModeEnum.待机模式);
                 foreach (var item in list)
                 {
                     ExceptionMessages.Add($"模组{item.ModuleCode}未成功退出入库模式！");
@@ -337,7 +342,7 @@ namespace WCS.BLL.HardWare
                 if (module.CurrentOutSns == null || module.CurrentOutSns.Count == 0)
                 {
                     Logs.Write($"GoInOutstoreByModule货架【{ShelfCode}】，模组【{module.ModuleCode}】，不存在需要继续出的物料，给其复位。", LogsType.Outstore);
-                    
+
                     //不需要这个模组继续亮灯了
                     module.GoOutOutStoreMode(TcpCleint);
                     Thread.Sleep(400);
@@ -368,7 +373,7 @@ namespace WCS.BLL.HardWare
                                 //查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
                                 var isLastShelf = ShelfManager.Shelves
                                                                  .Where(t => t.OrderNumber == OrderNumber)
-                                                                 .Where(t => t.CurrentMode == Mode.出库模式)
+                                                                 .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                                                  .Any();
                                 if (!isLastShelf)
                                 {
@@ -417,7 +422,7 @@ namespace WCS.BLL.HardWare
                                                              .ToList();
                                             var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList();
 
-                                            var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
+                                            var otherModeShelfs = shelfs.Where(t => t.CurrentMode != TaskModeEnum.待机模式).ToList();
                                             if (otherModeShelfs != null && otherModeShelfs.Count > 0)
                                             {
                                                 otherModeShelfs.ForEach(t =>
@@ -450,7 +455,7 @@ namespace WCS.BLL.HardWare
                                             Task.Run(() =>
                                             {
                                                 //判断是否是当前订单最后一个出库货架
-                                                var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber)
+                                                var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber)
                                                                                    .Any();
                                                 //WebSocket通知前台以更新左侧出库单列表的状态
                                                 if (!isOuting)
@@ -479,7 +484,7 @@ namespace WCS.BLL.HardWare
                                     Logs.Write($"发料单{OrderNumber}，非最后一个出库货架！", LogsType.Outstore);
                                     var otherShelfs = ShelfManager.Shelves
                                      .Where(t => t.OrderNumber == OrderNumber)
-                                     .Where(t => t.CurrentMode == Mode.出库模式)
+                                     .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                      .ToList();
 
                                     otherShelfs.ForEach(shelf =>
@@ -512,7 +517,7 @@ namespace WCS.BLL.HardWare
                                 Task.Run(() =>
                                 {
                                     //判断是否是当前订单最后一个出库货架
-                                    var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber)
+                                    var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber)
                                                                        .Any();
                                     //WebSocket通知前台以更新左侧出库单列表的状态
                                     if (!isOuting)
@@ -556,14 +561,14 @@ namespace WCS.BLL.HardWare
             try
             {
                 //第一步：设置货架当前模式
-                if (CurrentMode != Mode.待机模式)
+                if (CurrentMode != TaskModeEnum.待机模式)
                 {
                     Modules.ForEach(t => { t.Reset(TcpCleint); });
                     //复位需要点时间间隔才能响应指令
                     Thread.Sleep(1500);
                 }
-                //CurrentMode = Mode.出库模式;
-                SetCurrentMode(Mode.出库模式);
+                //CurrentMode = TaskModeEnum.出库模式;
+                SetCurrentMode(TaskModeEnum.出库模式);
                 //设置当前操作人
                 OutOperateUser = OperateUser;
 
@@ -605,7 +610,7 @@ namespace WCS.BLL.HardWare
                         timeSpan = DateTime.Now - beginTime;
 
                         //所有板子成功进入出库模式 表示进入出库模式成功，跳出循环
-                        var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.出库模式)
+                        var isExistsNotInstore = outModules.Where(t => t.CurrentMode != TaskModeEnum.出库模式)
                                                         .Where(t => t.IsEnable)
                                                         .Any();
                         if (!isExistsNotInstore)
@@ -615,7 +620,7 @@ namespace WCS.BLL.HardWare
                         //循环延时处理
                         Thread.Sleep(50);
                     }
-                    var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.出库模式).ToList();
+                    var list = outModules.Where(t => t.IsEnable && t.CurrentMode != TaskModeEnum.出库模式).ToList();
                     if (list != null && list.Count > 0)
                     {
                         var messages = list.Select(t => $"模组{t.ModuleCode}未进入出库模式！").ToList();
@@ -649,7 +654,7 @@ namespace WCS.BLL.HardWare
             {
                 Logs.Write($"货架【{ShelfCode}】，开始退出出库", LogsType.Outstore);
                 //找到在出库中的模组
-                var outingModules = Modules.Where(t => t.CurrentMode == Mode.出库模式)
+                var outingModules = Modules.Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                            .ToList();
                 foreach (var module in outingModules)
                 {
@@ -664,7 +669,7 @@ namespace WCS.BLL.HardWare
                     timeSpan = DateTime.Now - beginTime;
 
                     //所有板子成功退出出库模式 表示退出出库模式成功，跳出循环
-                    var isExistsOutstore = outingModules.Where(t => t.CurrentMode == Mode.出库模式)
+                    var isExistsOutstore = outingModules.Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                                           .Where(t => t.IsEnable)
                                                           .Any();
                     if (!isExistsOutstore)
@@ -674,7 +679,7 @@ namespace WCS.BLL.HardWare
                     //循环延时处理
                     Thread.Sleep(50);
                 }
-                var list = outingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.出库模式).ToList();
+                var list = outingModules.Where(t => t.IsEnable && t.CurrentMode == TaskModeEnum.出库模式).ToList();
                 if (list != null && list.Count > 0)
                 {
                     var messages = list.Select(t => $"模组{t.ModuleCode}未退出出库模式！").ToList();
@@ -696,13 +701,13 @@ namespace WCS.BLL.HardWare
 
                 CurrentOutStoreMatSNs.Clear();
                 WarningLight.CloseLight(TcpCleint);
-                SetCurrentMode(Mode.待机模式);
+                SetCurrentMode(TaskModeEnum.待机模式);
                 Logs.Write($"货架【{ShelfCode}】，结束退出出库", LogsType.Outstore);
 
                 //Task.Run(() =>
                 //{
                 //    //判断是否是当前订单最后一个出库货架
-                //    var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber)
+                //    var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber)
                 //                                       .Any();
                 //    //WebSocket通知前台以更新左侧出库单列表的状态
                 //    if (!isOuting)
@@ -730,19 +735,19 @@ namespace WCS.BLL.HardWare
             try
             {
                 //第一步：设置货架当前模式
-                if (CurrentMode != Mode.待机模式)
+                if (CurrentMode != TaskModeEnum.待机模式)
                 {
                     Modules.ForEach(t =>
                     {
-                        if (CurrentMode != Mode.待机模式)
+                        if (CurrentMode != TaskModeEnum.待机模式)
                             t.Reset(TcpCleint);
                     });
                     //复位需要点时间间隔才能响应指令
                     Thread.Sleep(1500);
                 }
 
-                //CurrentMode = Mode.盘点模式;
-                SetCurrentMode(Mode.盘点模式);
+                //CurrentMode = TaskModeEnum.盘点模式;
+                SetCurrentMode(TaskModeEnum.盘点模式);
 
                 //第二步：货架添加 盘点单号 记录当前盘点的发料单
                 CurrentStockTakingOrder = stockTakingOrder;
@@ -783,7 +788,7 @@ namespace WCS.BLL.HardWare
                         timeSpan = DateTime.Now - beginTime;
 
                         //所有板子成功进入盘点模式 表示进入盘点模式成功，跳出循环
-                        var isExistsNotInstore = outModules.Where(t => t.CurrentMode != Mode.盘点模式)
+                        var isExistsNotInstore = outModules.Where(t => t.CurrentMode != TaskModeEnum.盘点模式)
                                                         .Where(t => t.IsEnable)
                                                         .Any();
                         if (!isExistsNotInstore)
@@ -793,7 +798,7 @@ namespace WCS.BLL.HardWare
                         //循环延时处理
                         Thread.Sleep(50);
                     }
-                    var list = outModules.Where(t => t.IsEnable && t.CurrentMode != Mode.盘点模式).ToList();
+                    var list = outModules.Where(t => t.IsEnable && t.CurrentMode != TaskModeEnum.盘点模式).ToList();
                     if (list != null && list.Count > 0)
                     {
                         var messages = list.Select(t => $"模组{t.ModuleCode}未进入盘点模式！").ToList();
@@ -843,7 +848,7 @@ namespace WCS.BLL.HardWare
         public void GoOutStocktaking()
         {
             //找到在盘点中的模组
-            var stockTakingModules = Modules.Where(t => t.CurrentMode == Mode.盘点模式)
+            var stockTakingModules = Modules.Where(t => t.CurrentMode == TaskModeEnum.盘点模式)
                                        .ToList();
             foreach (var module in stockTakingModules)
             {
@@ -860,7 +865,7 @@ namespace WCS.BLL.HardWare
                     timeSpan = DateTime.Now - beginTime;
 
                     //所有板子成功退出盘点模式 表示退出盘点模式成功，跳出循环
-                    var isExistsNotInstore = stockTakingModules.Where(t => t.CurrentMode == Mode.盘点模式)
+                    var isExistsNotInstore = stockTakingModules.Where(t => t.CurrentMode == TaskModeEnum.盘点模式)
                                                           .Where(t => t.IsEnable)
                                                           .Any();
                     if (!isExistsNotInstore)
@@ -870,7 +875,7 @@ namespace WCS.BLL.HardWare
                     //循环延时处理
                     Thread.Sleep(50);
                 }
-                var list = stockTakingModules.Where(t => t.IsEnable && t.CurrentMode == Mode.盘点模式).ToList();
+                var list = stockTakingModules.Where(t => t.IsEnable && t.CurrentMode == TaskModeEnum.盘点模式).ToList();
                 if (list != null && list.Count > 0)
                 {
                     var messages = list.Select(t => $"模组{t.ModuleCode}未退出盘点模式！").ToList();
@@ -892,8 +897,8 @@ namespace WCS.BLL.HardWare
             });
             CurrentOutStoreMatSNs.Clear();
             WarningLight.CloseLight(TcpCleint);
-            //this.CurrentMode = Mode.待机模式;
-            SetCurrentMode(Mode.待机模式);
+            //this.CurrentMode = TaskModeEnum.待机模式;
+            SetCurrentMode(TaskModeEnum.待机模式);
         }
 
         public void Reset()
@@ -907,8 +912,8 @@ namespace WCS.BLL.HardWare
                 });
             }
             WarningLight.CloseLight(TcpCleint);
-            //this.CurrentMode = Mode.待机模式;
-            SetCurrentMode(Mode.待机模式);
+            //this.CurrentMode = TaskModeEnum.待机模式;
+            SetCurrentMode(TaskModeEnum.待机模式);
         }
 
         public void QueryVoltage(int moduleId)
@@ -929,7 +934,7 @@ namespace WCS.BLL.HardWare
             }
         }
 
-        public void SetCurrentMode(Mode mode)
+        public void SetCurrentMode(TaskModeEnum mode)
         {
             this.CurrentMode = mode;
             this.SetCurrentModeTime = DateTime.Now;
@@ -954,7 +959,7 @@ namespace WCS.BLL.HardWare
         {
             try
             {
-                if (CurrentMode == Mode.待机模式)
+                if (CurrentMode == TaskModeEnum.待机模式)
                     OrderNumber = "自检中...";
                 foreach (var module in Modules.Where(t => t.IsEnable).ToList())
                 {
@@ -1017,7 +1022,7 @@ namespace WCS.BLL.HardWare
             }
             finally
             {
-                if (CurrentMode == Mode.待机模式)
+                if (CurrentMode == TaskModeEnum.待机模式)
                     OrderNumber = string.Empty;
             }
         }
@@ -1130,7 +1135,7 @@ namespace WCS.BLL.HardWare
                 }
                 else
                 {
-                    module.CurrentMode = Mode.入库模式;
+                    module.CurrentMode = TaskModeEnum.入库模式;
                 }
             }
             //库存物料与实际情况不匹配
@@ -1143,7 +1148,7 @@ namespace WCS.BLL.HardWare
                 }
                 else
                 {
-                    module.CurrentMode = Mode.入库模式;
+                    module.CurrentMode = TaskModeEnum.入库模式;
                 }
                 //获取当前板所有库位
                 var storeInfos = DbHelp.db.Queryable<StoreInfo>()
@@ -1258,14 +1263,14 @@ namespace WCS.BLL.HardWare
         /// <param name="data"></param>
         public void GoOutInstoreProcess(byte[] data, int boardId, int lightNumber)
         {
-            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.入库模式).FirstOrDefault();
+            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == TaskModeEnum.入库模式).FirstOrDefault();
             if (module == null)
             {
                 return;
             }
             else
             {
-                module.CurrentMode = Mode.待机模式;
+                module.CurrentMode = TaskModeEnum.待机模式;
             }
         }
 
@@ -1467,11 +1472,7 @@ namespace WCS.BLL.HardWare
                             SolvedGuids = warnings.Select(t => t.Guid).ToList(),
                         };
                         WarningManager.SendWarning(warningModel);
-                        //自动消除本地缓存的报警
-                        warnings.ForEach(warning =>
-                        {
-                            WarningManager.ClearWarning(warning, SolveTypeEnum.忽略);
-                        });
+
 
                         ProcessingExceptions.RemoveAll(t => t.BoardId == boardId);
                     }
@@ -1555,7 +1556,7 @@ namespace WCS.BLL.HardWare
                 }
                 else
                 {
-                    module.CurrentMode = Mode.出库模式;
+                    module.CurrentMode = TaskModeEnum.出库模式;
                 }
             }
             //库存物料与实际情况不匹配
@@ -1569,7 +1570,7 @@ namespace WCS.BLL.HardWare
                 }
                 else
                 {
-                    module.CurrentMode = Mode.出库模式;
+                    module.CurrentMode = TaskModeEnum.出库模式;
                 }
                 //获取当前板所有库位
                 var storeInfos = DbHelp.db.Queryable<StoreInfo>()
@@ -1675,7 +1676,7 @@ namespace WCS.BLL.HardWare
 
         public void OutstoreReturnProcess(byte[] data, int boardId, int lightNumber)
         {
-            if (CurrentMode != Mode.出库模式)
+            if (CurrentMode != TaskModeEnum.出库模式)
             {
                 Logs.Write($"出库错误：{ShelfCode}该货架模式不是出库模式或盘点模式！", LogsType.Outstore);
                 return;
@@ -1807,7 +1808,7 @@ namespace WCS.BLL.HardWare
                 //更新时间 避免超时被自动退出
                 Task.Run(() =>
                 {
-                    var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber).ToList();
+                    var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber).ToList();
                     foreach (var shelf in shelves)
                     {
                         shelf.SetCurrentModeTime = DateTime.Now;
@@ -1862,7 +1863,7 @@ namespace WCS.BLL.HardWare
                             //查一下是否是当前发料单最后一个货架（在出库模式 同一个发料单下）
                             var isLastShelf = ShelfManager.Shelves
                                                              .Where(t => t.OrderNumber == OrderNumber)
-                                                             .Where(t => t.CurrentMode == Mode.出库模式)
+                                                             .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                                              .Any();
                             if (!isLastShelf)
                             {
@@ -1911,7 +1912,7 @@ namespace WCS.BLL.HardWare
                                                          .ToList();
                                         var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList();
 
-                                        var otherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).ToList();
+                                        var otherModeShelfs = shelfs.Where(t => t.CurrentMode != TaskModeEnum.待机模式).ToList();
                                         if (otherModeShelfs != null && otherModeShelfs.Count > 0)
                                         {
                                             otherModeShelfs.ForEach(t =>
@@ -1943,7 +1944,7 @@ namespace WCS.BLL.HardWare
                                         Task.Run(() =>
                                         {
                                             //判断是否是当前订单最后一个出库货架
-                                            var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber)
+                                            var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber)
                                                                                .Any();
                                             //WebSocket通知前台以更新左侧出库单列表的状态
                                             if (!isOuting)
@@ -1971,7 +1972,7 @@ namespace WCS.BLL.HardWare
                                 Logs.Write($"发料单{OrderNumber}，非最后一个出库货架！", LogsType.Outstore);
                                 var otherShelfs = ShelfManager.Shelves
                                  .Where(t => t.OrderNumber == OrderNumber)
-                                 .Where(t => t.CurrentMode == Mode.出库模式)
+                                 .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                  .ToList();
 
                                 otherShelfs.ForEach(shelf =>
@@ -2002,7 +2003,7 @@ namespace WCS.BLL.HardWare
                             Task.Run(() =>
                             {
                                 //判断是否是当前订单最后一个出库货架
-                                var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.OrderNumber == OrderNumber)
+                                var isOuting = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.OrderNumber == OrderNumber)
                                                                    .Any();
                                 //WebSocket通知前台以更新左侧出库单列表的状态
                                 if (!isOuting)
@@ -2087,14 +2088,14 @@ namespace WCS.BLL.HardWare
         /// <param name="data"></param>
         public void GoOutOutstoreProcess(byte[] data, int boardId, int lightNumber)
         {
-            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.出库模式).FirstOrDefault();
+            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == TaskModeEnum.出库模式).FirstOrDefault();
             if (module == null)
             {
                 return;
             }
             else
             {
-                module.CurrentMode = Mode.待机模式;
+                module.CurrentMode = TaskModeEnum.待机模式;
             }
         }
 
@@ -2140,12 +2141,6 @@ namespace WCS.BLL.HardWare
                             SolvedGuids = warnings.Select(t => t.Guid).ToList(),
                         };
                         WarningManager.SendWarning(warningModel);
-                        //自动消除本地缓存的报警
-                        warnings.ForEach(warning =>
-                        {
-                            Logs.Write($"ClearWarning,{warning.Guid}", LogsType.Outstore);
-                            WarningManager.ClearWarning(warning, SolveTypeEnum.忽略);
-                        });
                         ProcessingExceptions.RemoveAll(t => t.BoardId == boardId);
                     }
                     break;
@@ -2221,20 +2216,20 @@ namespace WCS.BLL.HardWare
             }
             else
             {
-                module.CurrentMode = Mode.盘点模式;
+                module.CurrentMode = TaskModeEnum.盘点模式;
             }
         }
 
         public void GoOutStockTakingReturnProcess(byte[] data, int boardId, int lightNumber)
         {
-            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == Mode.盘点模式).FirstOrDefault();
+            var module = this.Modules.Where(t => t.BoardId == boardId && t.CurrentMode == TaskModeEnum.盘点模式).FirstOrDefault();
             if (module == null)
             {
                 return;
             }
             else
             {
-                module.CurrentMode = Mode.待机模式;
+                module.CurrentMode = TaskModeEnum.待机模式;
             }
         }
 
@@ -2249,7 +2244,7 @@ namespace WCS.BLL.HardWare
             }
             else
             {
-                module.CurrentMode = Mode.待机模式;
+                module.CurrentMode = TaskModeEnum.待机模式;
             }
         }
 

WCS.BLL/HardWare/SmartShelfModule.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TouchSocket.Core;
 using WCS.BLL.Config;
+using WCS.BLL.DbModels.Task;
 using WCS.DAL.Db;
 using WCS.DAL.DbModels;
 
@@ -97,7 +98,7 @@ namespace WCS.BLL.HardWare
         public string ModuleCode { get; set; }
         public int BoardId { get; set; }
         public bool IsEnable { get; set; }
-        public Mode CurrentMode { get; set; }
+        public TaskModeEnum CurrentMode { get; set; }
         /// <summary>
         /// 是否已发送自检命令
         /// </summary>
@@ -112,7 +113,7 @@ namespace WCS.BLL.HardWare
 
         public void GoInInstoreMode(TCPClient tcpClient)
         {
-            if (CurrentMode != Mode.待机模式)
+            if (CurrentMode != TaskModeEnum.待机模式)
             {
                 //TO DO 退出对应的模式 然后再发送进入入库模式
             }
@@ -122,12 +123,22 @@ namespace WCS.BLL.HardWare
                                      .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());
@@ -136,6 +147,13 @@ namespace WCS.BLL.HardWare
             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));
         }
 
@@ -151,7 +169,7 @@ namespace WCS.BLL.HardWare
 
         public void GoOutInstoreMode(TCPClient tcpClient)
         {
-            if (CurrentMode == Mode.入库模式)
+            if (CurrentMode == TaskModeEnum.入库模式)
             {
                 tcpClient.Send(tcpClient.GenerateMessage(BoardId, GoOutInstoreData));
             }
@@ -177,7 +195,7 @@ namespace WCS.BLL.HardWare
         /// <param name="tcpClient"></param>
         public void ShelfCheck(TCPClient tcpClient)
         {
-            if (CurrentMode != Mode.待机模式)
+            if (CurrentMode != TaskModeEnum.待机模式)
             {
                 return;
             }
@@ -187,12 +205,21 @@ namespace WCS.BLL.HardWare
                                                  .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());
@@ -201,6 +228,13 @@ namespace WCS.BLL.HardWare
             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));
         }
 
@@ -218,12 +252,21 @@ namespace WCS.BLL.HardWare
                                       .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());
@@ -232,6 +275,13 @@ namespace WCS.BLL.HardWare
             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)
             {

WCS.BLL/Manager/DbInit.cs

@@ -62,7 +62,7 @@ namespace WCS.BLL.Manager
             }
             //手动修改后台配置后再进行CodeFirst 数据库的生成、表的生成
             //如果不配置此参数 每次启动都会持续几十秒才能成功启动后端
-            if (LocalFile.Config.IsResetDBOrTable)
+            if (true)
             {
                 #region 建库建表 只在表有变动时运行
                 DbHelp.db.DbMaintenance.CreateDatabase();
@@ -76,8 +76,11 @@ 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));
+
                 Logs.Write("【初始化数据库】db（业务数据库）建表", LogsType.StartBoot);
                 DbHelp.dbLog.CodeFirst.InitTables(typeof(SystemApiLogRecord));
                 Logs.Write("【初始化数据库】dblog（日志数据库）建表", LogsType.StartBoot);

WCS.BLL/Manager/MKYBackgroundThread.cs

@@ -0,0 +1,233 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WCS.BLL.DbModels.Task;
+using WCS.BLL.DbModels;
+using WCS.BLL.HardWare;
+using WCS.DAL.Db.AuthDb;
+using WCS.DAL.Db;
+using WCS.DAL;
+using WCS.Model.ApiModel.InOutRecord;
+using WCS.Model.ApiModel.MXBackgroundThread;
+using WCS.Model;
+using WCS.BLL.Tool;
+using SqlSugar;
+using WCS.BLL.Config;
+using WCS.Model.ApiModel.MKYBackgroundThread;
+using System.Text.RegularExpressions;
+using System.Reflection;
+
+namespace WCS.BLL.Manager
+{
+    public static class MKYBackgroundThread
+    {
+        public static void InitBackgroundThread()
+        {
+            #region 调用WMS接口获取具体的库存列表并展示在液晶标签上
+            #endregion
+
+            #region 定时任务：回传数据至WMS系统
+            Task.Run(() =>
+            {
+                while (true)
+                {
+                    //回传数据的时间间隔
+                    Thread.Sleep(2000);
+                    //先判断是否需要获取token
+                    if (string.IsNullOrEmpty(LocalStatic.WMSToken))
+                    {
+                        try
+                        {
+                            Logs.Write($"【定时任务：回传数据至WMS系统】token为空 开始获取token", LogsType.Info);
+                            #region 登录获取token
+                            var request = new LoginRequest()
+                            {
+                                userName = "cmeimZtwcs",
+                                password = "Cmeim@ztwcs2024!@#"
+                            };
+                            var result = ApiHelp.GetDataFromHttpShortTime<LoginResponse>(@"http://10.41.235.10:8989/login", request, "POST", true);
+                            if (result != null && (result.code == 200))
+                            {
+                                //获取到最新的token
+                                LocalStatic.WMSToken = result.data;
+                                Logs.Write($"【定时任务：回传数据至WMS系统】调用接口获取token成功！token为{result.data}", LogsType.Info);
+                            }
+                            else if (result != null && (result.code == 500) && result.message.Contains("未查询到条码信息【"))
+                            {
+                                Logs.Write($"【定时任务：回传数据至WMS系统】调用接口获取token失败", LogsType.Info);
+                            }
+                            #endregion
+                        }
+                        catch (Exception ex)
+                        {
+                            Logs.Write($"【定时任务：回传数据至WMS系统】获取token异常" + ex.Message, LogsType.Info);
+                            Logs.Write($"【定时任务：回传数据至WMS系统】获取token异常" + ex.StackTrace, LogsType.Info);
+                        }
+                    }
+
+                    try
+                    {
+                        //获取已完成未提交的任务
+                        var finsishedTaks = DbHelp.db.Queryable<FinishedTask>()
+                                                 .Where(t => t.FinishTime > DateTime.Now.AddDays(-1))//只上传1天内的 后续调整
+                                                 .OrderBy(t => t.FinishTime)
+                                                 .ToList();
+                        //循环进行上传
+                        for (int i = 0; i < finsishedTaks.Count; i++)
+                        {
+                            var finishedTask = finsishedTaks[i];
+                            try
+                            {
+                                //上传单据
+                                #region 上传单据
+                                var request = new SysOrderRequest()
+                                {
+                                    guid = finishedTask.Guid.ToString(),
+                                    itemNo = finishedTask.ItemNo,
+                                    matCode = finishedTask.MatCode,
+                                    matBatch = finishedTask.MatBatch,
+                                    matSN = finishedTask.MatSN,
+                                    orderNumber = finishedTask.OrderNumber,
+                                    orderType = (int)finishedTask.TaskMode,
+                                    storeCode = finishedTask.ModuleCode,
+                                    qty = finishedTask.FinishQty
+                                };
+                                var result = ApiHelp.GetDataFromHttp<SysOrderResponse>(@"http://10.41.235.10:8989/ztwcs/stockBillBack", request, "POST", true);
+                                if (result != null && (result.code == 200))
+                                {
+                                    //上传成功
+                                    var uploadedTask = new UploadededTask()
+                                    {
+                                        ShelfId = finishedTask.ShelfId,
+                                        ShelfCode = finishedTask.ShelfCode,
+                                        ModuleId = finishedTask.ModuleId,
+                                        ModuleCode = finishedTask.ModuleCode,
+                                        StoreId = finishedTask.StoreId,
+                                        StoreCode = finishedTask.StoreCode,
+                                        TaskID = finishedTask.TaskID,
+                                        ItemNo = finishedTask.ItemNo,
+                                        Guid = finishedTask.Guid,
+                                        TaskMode = finishedTask.TaskMode,
+                                        OrderNumber = finishedTask.OrderNumber,
+                                        ButtonColor = finishedTask.ButtonColor,
+                                        MatCode = finishedTask.MatCode,
+                                        MatName = finishedTask.MatName,
+                                        MatSpec = finishedTask.MatSpec,
+                                        MatBatch = finishedTask.MatBatch,
+                                        MatSN = finishedTask.MatSN,
+                                        Qty = finishedTask.Qty,
+                                        CreateTime = finishedTask.CreateTime,
+                                        FinishQty = finishedTask.FinishQty,
+                                        FinishTime = finishedTask.FinishTime,
+                                        UploadTime = DateTime.Now,
+                                    };
+                                    DbHelp.db.Insertable(uploadedTask).ExecuteCommand();
+                                    DbHelp.db.Deleteable(finishedTask).ExecuteCommand();
+                                }
+                                //上传成功 但是此物料已经被删除！！！
+                                else if (result != null && (result.code == 500) && result.message.Contains("未查询到条码信息【"))
+                                {
+                                    //上传成功 
+                                    var uploadedTask = new UploadededTask()
+                                    {
+                                        ShelfId = finishedTask.ShelfId,
+                                        ShelfCode = finishedTask.ShelfCode,
+                                        ModuleId = finishedTask.ModuleId,
+                                        ModuleCode = finishedTask.ModuleCode,
+                                        StoreId = finishedTask.StoreId,
+                                        StoreCode = finishedTask.StoreCode,
+                                        TaskID = finishedTask.TaskID,
+                                        ItemNo = finishedTask.ItemNo,
+                                        Guid = finishedTask.Guid,
+                                        TaskMode = finishedTask.TaskMode,
+                                        OrderNumber = finishedTask.OrderNumber,
+                                        ButtonColor = finishedTask.ButtonColor,
+                                        MatCode = finishedTask.MatCode,
+                                        MatName = finishedTask.MatName,
+                                        MatSpec = finishedTask.MatSpec,
+                                        MatBatch = finishedTask.MatBatch,
+                                        MatSN = finishedTask.MatSN + "(已删除)",
+                                        Qty = finishedTask.Qty,
+                                        CreateTime = finishedTask.CreateTime,
+                                        FinishQty = finishedTask.FinishQty,
+                                        FinishTime = finishedTask.FinishTime,
+                                        UploadTime = DateTime.Now,
+                                    };
+                                    DbHelp.db.Insertable(uploadedTask).ExecuteCommand();
+                                    DbHelp.db.Deleteable(finishedTask).ExecuteCommand();
+                                }
+                                else if (result != null && (result.code == 10000) &&
+(result.message.Contains("token") || result.message.Contains("请重新登录") || result.message.Contains("无token") || result.message.Contains("无效token") || result.message.Contains("token校验失败"))
+)
+                                {
+                                    Logs.Write($"【定时任务：回传数据至WMS系统】根据wms接口返回 token已过期或者错误，清空token。", LogsType.Info);
+                                    LocalStatic.WMSToken = string.Empty;
+                                    break;
+                                }
+                                else if (result != null && (result.code == 500) && 
+                                (result.message.Contains("token") || result.message.Contains("请重新登录") || result.message.Contains("无token") || result.message.Contains("无效token") || result.message.Contains("token校验失败"))
+                                )
+                                {
+                                    Logs.Write($"【定时任务：回传数据至WMS系统】根据wms接口返回 token已过期或者错误，清空token。", LogsType.Info);
+                                    LocalStatic.WMSToken = string.Empty;
+                                    break;
+                                }
+                                #endregion
+
+                                //为了调试 
+                                //Random random = new Random();
+                                //int number = random.Next(1 , 100);
+                                //if (number <= 30)
+                                //{
+                                //    //上传成功
+                                //    var uploadedTask = new UploadededTask()
+                                //    {
+                                //        ShelfId = finishedTask.ShelfId,
+                                //        ShelfCode = finishedTask.ShelfCode,
+                                //        ModuleId = finishedTask.ModuleId,
+                                //        ModuleCode = finishedTask.ModuleCode,
+                                //        StoreId = finishedTask.StoreId,
+                                //        StoreCode = finishedTask.StoreCode,
+                                //        TaskID = finishedTask.TaskID,
+                                //        ItemNo = finishedTask.ItemNo,
+                                //        Guid = finishedTask.Guid,
+                                //        TaskMode = finishedTask.TaskMode,
+                                //        OrderNumber = finishedTask.OrderNumber,
+                                //        ButtonColor = finishedTask.ButtonColor,
+                                //        MatCode = finishedTask.MatCode,
+                                //        MatName = finishedTask.MatName,
+                                //        MatSpec = finishedTask.MatSpec,
+                                //        MatBatch = finishedTask.MatBatch,
+                                //        MatSN = finishedTask.MatSN,
+                                //        Qty = finishedTask.Qty,
+                                //        CreateTime = finishedTask.CreateTime,
+                                //        FinishQty = finishedTask.FinishQty,
+                                //        FinishTime = finishedTask.FinishTime,
+                                //        UploadTime = DateTime.Now,
+                                //    };
+                                //    DbHelp.db.Insertable(uploadedTask).ExecuteCommand();
+                                //    DbHelp.db.Deleteable(finishedTask).ExecuteCommand();
+                                //}
+
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【定时任务：回传数据至WMS系统】{finishedTask.ItemNo}发生异常," + ex.Message, LogsType.Info);
+                                Logs.Write($"【定时任务：回传数据至WMS系统】{finishedTask.ItemNo}发生异常" + ex.StackTrace, LogsType.Info);
+                            }
+                            Thread.Sleep(500);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        Logs.Write("【定时任务：回传数据至WMS系统】发生异常" + e.Message, LogsType.Info);
+                        Logs.Write("【定时任务：回传数据至WMS系统】发生异常" + e.StackTrace, LogsType.Info);
+                    }
+                }
+            });
+            #endregion
+        }
+    }
+}

WCS.BLL/Manager/MXBackgroundThread.cs

@@ -1,6 +1,7 @@
 using SqlSugar;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.HardWare;
 using WCS.BLL.Tool;
 using WCS.DAL;
@@ -128,7 +129,7 @@ namespace WCS.BLL.Manager
                     try
                     {
                         #region 入库模式
-                        var inStoreShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.入库模式)
+                        var inStoreShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.入库模式)
                                                    .Where(t => DateTime.Now - t.SetCurrentModeTime >= TimeSpan.FromMinutes(3))
                                                    .ToList();
                         foreach (var shelf in inStoreShelf)
@@ -140,7 +141,7 @@ namespace WCS.BLL.Manager
 
                         #region 出库模式
                         //出库超过n分钟自动进入待机模式
-                        var outStoreShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式)
+                        var outStoreShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                                   .Where(t => DateTime.Now - t.SetCurrentModeTime >= TimeSpan.FromMinutes(5))
                                                   .ToList();
                         foreach (var shelf in outStoreShelf)
@@ -151,7 +152,7 @@ namespace WCS.BLL.Manager
                         #endregion
 
                         #region 盘点模式
-                        var stockTakingShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.盘点模式)
+                        var stockTakingShelf = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.盘点模式)
                                                   .Where(t => DateTime.Now - t.SetCurrentModeTime >= TimeSpan.FromMinutes(5))
                                                   .ToList();
                         foreach (var shelf in stockTakingShelf)
@@ -272,7 +273,7 @@ namespace WCS.BLL.Manager
                     try
                     {
                         //待机模式未关灯
-                        var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.待机模式 && t.LightColor != WarningLight.LightColorEnum.关闭)
+                        var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.待机模式 && t.LightColor != WarningLight.LightColorEnum.关闭)
                                                           .Where(t => t.SetCurrentModeTime < DateTime.Now.AddSeconds(-5))
                                                           .ToList();
                         foreach (var shelf in shelves)
@@ -296,7 +297,7 @@ namespace WCS.BLL.Manager
                         }
 
                         //出库模式未亮灯
-                        var outShelves = ShelfManager.Shelves.Where(t => t.CurrentMode == Mode.出库模式 && t.LightColor == WarningLight.LightColorEnum.关闭)
+                        var outShelves = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.出库模式 && t.LightColor == WarningLight.LightColorEnum.关闭)
                                             .Where(t => t.SetCurrentModeTime < DateTime.Now.AddSeconds(-5))
                                             .ToList();
                         foreach (var shelf in outShelves)

WCS.BLL/Manager/ShelfManager.cs

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

WCS.BLL/Manager/TCPClientManager.cs

@@ -23,12 +23,15 @@ namespace WCS.BLL.Manager
         /// </summary>
         public static List<TCPClient> TCPClients = new List<TCPClient>();
 
+        public static TcpService Service { get; set; }
+
         public static void InitTcpClient()
         {
+            #region  模块是Service的逻辑
             Logs.Write("【InitTcpClient】开始", LogsType.StartBoot);
-
-            var clientsInDB = DbHelp.db.Queryable<ShelfInfo>()
+            var moduleServices = DbHelp.db.Queryable<ShelfInfo>()
                                .WhereIF(!string.IsNullOrEmpty(LocalFile.Config.GroupName), t => t.GroupName == LocalFile.Config.GroupName)
+                               .Where(t => t.IsService)
                                .Select(t => new
                                {
                                    IP = t.ClientIp,
@@ -37,154 +40,195 @@ namespace WCS.BLL.Manager
                                })
                                .Distinct()
                                .ToList();
-            Logs.Write($"【InitTcpClient】需要连接的服务端地址如下：\r\n{string.Join(";", clientsInDB)}", LogsType.StartBoot);
-            foreach (var cleientInDB in clientsInDB)
+            if (moduleServices != null && moduleServices.Count > 0)
             {
+                Logs.Write($"【InitTcpClient】需要连接的服务端地址如下：\r\n{string.Join(";", moduleServices)}", LogsType.StartBoot);
+                foreach (var cleientInDB in moduleServices)
+                {
+                    Task.Run(() =>
+                    {
+                        var tcpCleint = new TCPClient(cleientInDB.IP, cleientInDB.Port, cleientInDB.ShelfTypeName);
+                        tcpCleint.tcpReceiveClient.Received += (client, e) =>
+                        {
+                            var clientIpHost = client.IP + ":" + client.Port;
+                            var TcpCleint = TCPClientManager.GetTCPClientByIPHost(clientIpHost);
+                            if (TcpCleint == null)
+                            {
+                                return EasyTask.CompletedTask;
+                            }
+
+                            var data = e.ByteBlock.Buffer.Take((int)e.ByteBlock.Length).ToArray();
+
+
+                            Logs.Write($"【接收{clientIpHost}】{BitConverter.ToString(data)}", LogsType.Instructions);
+
+                            e.ByteBlock.Clear();
+                            var len = data.Length;
+
+                            if (tcpCleint.ShelfTypeName == "液晶标签货架")
+                            {
+                                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)
+                                    {
+                                        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);
+                                    }
+                                }
+                            }
+                            return EasyTask.CompletedTask;
+                        };
+                        //配置首次连接后复位操作
+                        tcpCleint.tcpSendClient.Connected += (client, e) =>
+                        {
+                            Logs.Write($"【TcpClient】{client.IP}完成连接,端口号{client.Port}", LogsType.StartBoot);
+                            var clientIpHost = client.IP + ":" + client.Port;
+                            var TcpCleint = TCPClientManager.GetTCPClientByIPHost(clientIpHost);
+                            if (TcpCleint == null)
+                            {
+                                return EasyTask.CompletedTask;
+                            }
+                            ////首次连接
+                            if (TcpCleint.IsFirstConnected == false)
+                            {
+                                Logs.Write($"【InitTcpClient】{clientIpHost}完成首次连接", LogsType.StartBoot);
+
+
+
+                                Console.WriteLine($"【InitTcpClient】{clientIpHost}完成首次连接");
+                                //InitStatus(TcpCleint);
+                                TcpCleint.IsFirstConnected = true;
+                                //获取剩余未完成连接的tcp
+                                var noFirstConnectedTcps = TCPClientManager.TCPClients.Where(t => t.IsFirstConnected == false)
+                                                                                       .Select(t => t.RemoteIPHost)
+                                                                                       .ToList();
+                                Logs.Write($"【InitTcpClient】剩余未完成连接的TCP为{string.Join(";", noFirstConnectedTcps)}", LogsType.StartBoot);
+                            }
+                            return EasyTask.CompletedTask;
+                        };
+
+                        lock (TCPClients)//避免添加失败的情况
+                        {
+                            TCPClients.Add(tcpCleint);
+                        }
+
+                        tcpCleint.Connect();
+                    });
+                }
+
+                //启动线程监听所有TCP是否已经完成首次连接
                 Task.Run(() =>
                 {
-                    var tcpCleint = new TCPClient(cleientInDB.IP, cleientInDB.Port, cleientInDB.ShelfTypeName);
-                    tcpCleint.tcpClient.Received += (client, e) =>
+                    while (true)
                     {
-                        var clientIpHost = client.IP + ":" + client.Port;
-                        var TcpCleint = TCPClientManager.GetTCPClientByIPHost(clientIpHost);
-                        if (TcpCleint == null)
+                        try
                         {
-                            return EasyTask.CompletedTask;
-                        }
-
-                        var data = e.ByteBlock.Buffer.Take((int)e.ByteBlock.Length).ToArray();
-
-
-                        Logs.Write($"【接收{clientIpHost}】{BitConverter.ToString(data)}", LogsType.Instructions);
-
-                        e.ByteBlock.Clear();
-                        var len = data.Length;
-
-                        if (tcpCleint.ShelfTypeName == "信息化货架")
-                        {
-                            Logs.Write($"【信息化货架开始处理接收数据】{BitConverter.ToString(data)}", LogsType.InstructionsProcess);
-                            Helper.ReturnDataProcess(TcpCleint, data);
-                            Logs.Write($"【信息化货架完成处理接收数据】{BitConverter.ToString(data)}", LogsType.InstructionsProcess);
-                            return EasyTask.CompletedTask;
-                        }
-
-                        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)
+                            Thread.Sleep(1000);
+                            var noFirstConnectedClients = TCPClientManager.TCPClients.Where(t => t.IsFirstConnected == false)
+                                                                                     .ToList();
+                            if (noFirstConnectedClients.Count == 0)
                             {
-                                var dataTemp = data.Skip(index).Take(TcpCleint.PreFixLength + TcpCleint.DataLength).ToArray();
-                                if (dataTemp.Length < TcpCleint.PreFixLength + TcpCleint.DataLength)//拆包后不满足一条指令的长度
+                                break;
+                            }
+                            else
+                            {
+                                Console.WriteLine($"存在tcp未完成首次连接，继续重连！");
+                                noFirstConnectedClients.ForEach(t =>
                                 {
-                                    continue;
-                                }
-                                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);
+                                    t.ReConnectAsync();
+                                });
                             }
                         }
-                        return EasyTask.CompletedTask;
-                    };
-                    //配置首次连接后复位操作
-                    tcpCleint.tcpClient.Connected += (client, e) =>
-                    {
-                        Logs.Write($"【TcpClient】{client.IP}完成连接,端口号{client.Port}", LogsType.StartBoot);
-                        var clientIpHost = client.IP + ":" + client.Port;
-                        var TcpCleint = TCPClientManager.GetTCPClientByIPHost(clientIpHost);
-                        if (TcpCleint == null)
+                        catch (Exception ex)
                         {
-                            return EasyTask.CompletedTask;
+
                         }
-                        //首次连接
-                        if (TcpCleint.IsFirstConnected == false)
-                        {
-                            Logs.Write($"【InitTcpClient】{clientIpHost}完成首次连接", LogsType.StartBoot);
-
-
-
-                            Console.WriteLine($"【InitTcpClient】{clientIpHost}完成首次连接");
-                            InitStatus(TcpCleint);
-                            TcpCleint.IsFirstConnected = true;
-                            //获取剩余未完成连接的tcp
-                            var noFirstConnectedTcps = TCPClientManager.TCPClients.Where(t => t.IsFirstConnected == false)
-                                                                                   .Select(t => t.RemoteIPHost)
-                                                                                   .ToList();
-                            Logs.Write($"【InitTcpClient】剩余未完成连接的TCP为{string.Join(";", noFirstConnectedTcps)}", LogsType.StartBoot);
-                        }
-                        return EasyTask.CompletedTask;
-                    };
-
-                    lock (TCPClients)//避免添加失败的情况
-                    {
-                        TCPClients.Add(tcpCleint);
                     }
-
-                    tcpCleint.Connect();
                 });
+                Logs.Write("【InitTcpClient】完成 后台继续连接", LogsType.StartBoot);
             }
+            #endregion
 
-            //启动线程监听所有TCP是否已经完成首次连接
-            Task.Run(() =>
+            #region 模块是Client的逻辑
+            var moduleClients = DbHelp.db.Queryable<ShelfInfo>()
+                   .WhereIF(!string.IsNullOrEmpty(LocalFile.Config.GroupName), t => t.GroupName == LocalFile.Config.GroupName)
+                   .Where(t => t.IsService == false)
+                   .Select(t => new
+                   {
+                       IP = t.ClientIp,
+                       ShelfTypeName = t.ShelfTypeName,
+                       Port = t.Port,
+                   })
+                   .Distinct()
+                   .ToList();
+            //有客户端作客户端时才需要初始化一个服务端
+            if (moduleClients != null && moduleClients.Count > 0)
             {
-                while (true)
+                Service = new TcpService();
+                Service.Connecting = (client, e) =>
                 {
-                    try
-                    {
-                        Thread.Sleep(1000);
-                        var noFirstConnectedClients = TCPClientManager.TCPClients.Where(t => t.IsFirstConnected == false)
-                                                                                 .ToList();
-                        if (noFirstConnectedClients.Count == 0)
-                        {
-                            break;
-                        }
-                        else
-                        {
-                            Console.WriteLine($"存在tcp未完成首次连接，继续重连！");
-                            noFirstConnectedClients.ForEach(t =>
-                            {
-                                t.ReConnectAsync();
-                            });
-                        }
-                    }
-                    catch (Exception ex)
-                    {
+                    return EasyTask.CompletedTask;
+                };//有客户端正在连接
+                Service.Connected = (client, e) => { return EasyTask.CompletedTask; };//有客户端成功连接
+                Service.Disconnecting = (client, e) => { return EasyTask.CompletedTask; };//有客户端正在断开连接，只有当主动断开时才有效。
+                Service.Disconnected = (client, e) => { return EasyTask.CompletedTask; };//有客户端断开连接
+                Service.Received = (client, e) =>
+                {
+                    //从客户端收到信息
+                    var mes = Encoding.UTF8.GetString(e.ByteBlock.Buffer, 0, e.ByteBlock.Len);//注意：数据长度是byteBlock.Len
+                    client.Logger.Info($"已从{client.Id}接收到信息：{mes}");
 
-                    }
-                }
-            });
-            Logs.Write("【InitTcpClient】完成 后台继续连接", LogsType.StartBoot);
+                    //client.Send(mes);//将收到的信息直接返回给发送方
+
+
+                    return EasyTask.CompletedTask;
+                };
+
+                Service.Setup(new TouchSocketConfig()//载入配置
+                    .SetListenIPHosts("tcp://0.0.0.0:9999", 7790)//同时监听两个地址
+                    .ConfigureContainer(a =>//容器的配置顺序应该在最前面
+                    {
+                        a.AddConsoleLogger();//添加一个控制台日志注入（注意：在maui中控制台日志不可用）
+                    })
+                    .ConfigurePlugins(a =>
+                    {
+                        //a.Add();//此处可以添加插件
+                    }));
+
+                Service.Start();
+            }
+            #endregion
         }
 
         //后台启动时给所有板子、警示灯发送复位操作 保持状态一致

WCS.BLL/Manager/WarningManager.cs

@@ -7,6 +7,7 @@ using System.Text;
 using System.Threading.Tasks;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.HardWare;
 using WCS.DAL.Db;
 using WCS.DAL.DbModels;
@@ -363,15 +364,15 @@ namespace WCS.BLL.Manager
                         {
                             switch (smartShelf.CurrentMode)
                             {
-                                case Mode.入库模式:
+                                case TaskModeEnum.入库模式:
                                     module.GoInInstoreMode(smartShelf.TcpCleint);
                                     smartShelf.WarningLight.BlueLight(smartShelf.TcpCleint);
                                     break;
-                                case Mode.出库模式:
+                                case TaskModeEnum.出库模式:
                                     Logs.Write("smartShelf.GoInOutstoreByWebSocket", LogsType.WebSocket);
                                     smartShelf.GoInOutstoreByWebSocket(module.ModuleId);
                                     break;
-                                case Mode.待机模式:
+                                case TaskModeEnum.待机模式:
                                     module.Reset(smartShelf.TcpCleint);
                                     smartShelf.WarningLight.CloseLight(smartShelf.TcpCleint);
                                     break;

WCS.BLL/Services/IService/IMXL4Service.cs

@@ -16,5 +16,16 @@ namespace WCS.BLL.Services.IService
     public interface IMXL4Service
     {
         public Task<ResponseCommon<object>> sysOrderMXL4(SysOrderMXL4Request request);
+
+        public Task<ResponseCommon<object>> cancelOrderMXL4(CancelRequest request);
+
+        public Task<ResponseCommon<object>> cancelOrderByCode(CancelOrderByCodeRequest request);
+
+        public Task<ResponseCommon> refreshInventoryRequest(RefreshInventoryRequest request);
+
+        #region 调试用的APi
+        public Task<ResponseCommon> reSetAll();
+        public Task<ResponseCommon> defaultDisplay();
+        #endregion
     }
 }

WCS.BLL/Services/IService/ISingleLightService.cs

@@ -15,5 +15,11 @@ namespace WCS.BLL.Services.IService
     public interface ISingleLightService
     {
         public Task<ResponseCommon<object>> SingleLightControl(SingleLightControlRequest request);
+        /// <summary>
+        /// 按区域一键灭灯
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public Task<ResponseCommon<object>> TurnoffLightByArea(TurnoffLightByAreaRequest request);
     }
 }

WCS.BLL/Services/Service/InstoreService.cs

@@ -5,6 +5,7 @@ using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.HardWare;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
@@ -16,6 +17,7 @@ using WCS.Model;
 using WCS.Model.ApiModel.InOutRecord;
 using WCS.Model.ApiModel.InStore;
 using WCS.Model.ApiModel.MXBackgroundThread;
+using static Dm.net.buffer.ByteArrayBuffer;
 
 namespace WCS.BLL.Services.Service
 {
@@ -68,7 +70,7 @@ namespace WCS.BLL.Services.Service
                 //已找到模组对应货架
                 shelf.GoInInstore(request.IpAdress);
 
-                if (shelf.CurrentMode == Mode.入库模式)
+                if (shelf.CurrentMode == TaskModeEnum.入库模式)
                     //成功进入入库模式
                     return new ShelfGoInInstoreResponse()
                     {
@@ -157,7 +159,7 @@ namespace WCS.BLL.Services.Service
                     };
                 }
                 //判断当前是否是入库模式
-                if (shelf.CurrentMode != Mode.入库模式)
+                if (shelf.CurrentMode != TaskModeEnum.入库模式)
                 {
                     return new ResponseCommon<MatInfo>()
                     {
@@ -381,7 +383,7 @@ namespace WCS.BLL.Services.Service
             }
 
             //判断当前是否是入库模式
-            if (shelf.CurrentMode != Mode.入库模式)
+            if (shelf.CurrentMode != TaskModeEnum.入库模式)
             {
                 return new ResponseCommon()
                 {

WCS.BLL/Services/Service/MXL4Service.cs

@@ -2,12 +2,16 @@
 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;
 using System.Xml.Xsl;
 using TouchSocket.Core;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
+using WCS.BLL.HardWare;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.BLL.Tool;
@@ -36,19 +40,19 @@ namespace WCS.BLL.Services.Service
                 var storeCodeList = request.List.Select(t => t.StoreCode)
                                                 .Distinct()
                                                 .ToList();
-                var stores = DbHelp.db.Queryable<StoreInfo>()
+                var moduleInfo = 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 == "液晶标签货架" || sti.ShelfTypeName == "信息化货架")
+                                      .Where((si, sti) => storeCodeList.Contains(si.ModuleCode))
+                                      .Select((si, sti) => si)
                                       .ToList();
-                if (stores.Count < storeCodeList.Count)
+                if (moduleInfo.Count < storeCodeList.Count)
                 {
-                    var storeCodesInDB = stores.Select(t => t.StoreCode).ToList();
+                    var storeCodesInDB = moduleInfo.Select(t => t.ModuleCode).ToList();
                     storeCodeList.RemoveAll(t => storeCodesInDB.Contains(t));
                     return new ResponseCommon<object>
                     {
-                        Code = 200,
+                        Code = 201,
                         Message = $"操作失败：库位【{string.Join(",", storeCodeList)}】不存在！",
                     };
                 }
@@ -64,29 +68,96 @@ namespace WCS.BLL.Services.Service
                     var task = currenTasksNotThisMode.First();
                     return new ResponseCommon<object>
                     {
-                        Code = 200,
+                        Code = 201,
                         Message = $"操作失败：库位【{task.StoreCode}】当前在{task.TaskMode}！",
                     };
                 }
+
+                //获取taskId
+                var list = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };
+                //已存在的taskID
+                var exsitIds = currenTasks.Select(t => t.TaskID)
+                                          .ToList();
+                exsitIds.ForEach(t =>
+                {
+                    list.RemoveAll(l => l == t);
+                });
+
+                var buttonColor = ButtonColorEnum.绿色;
+                //转换颜色
+                switch (request.Corlor)
+                {
+                    case "红":
+                        buttonColor = ButtonColorEnum.红色;
+                        break;
+                    case "绿":
+                        buttonColor = ButtonColorEnum.绿色;
+                        break;
+                    case "黄":
+                        buttonColor = ButtonColorEnum.黄色;
+                        break;
+                    case "蓝":
+                        buttonColor = ButtonColorEnum.蓝色;
+                        break;
+                    case "紫":
+                        buttonColor = ButtonColorEnum.紫色;
+                        break;
+                    case "青":
+                        buttonColor = ButtonColorEnum.青色;
+                        break;
+                    case "白":
+                        buttonColor = ButtonColorEnum.白色;
+                        break;
+                    default:
+                        break;
+                }
+
+
                 var tasks = new List<CurrentTask>();
                 //生成任务数据
                 foreach (var orderDetail in request.List)
                 {
-                    var store = stores.Where(t => t.StoreCode == orderDetail.StoreCode).First();
+                    list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };
+                    var module = moduleInfo.Where(t => t.ModuleCode == orderDetail.StoreCode).First();
+
+                    var currentTaskIds = DbHelp.db.Queryable<CurrentTask>()
+                                                  .Where(t => t.ModuleId == module.Id)
+                                                  .Select(t => t.TaskID)
+                                                  .ToList();
+                    var tasksIds = tasks.Where(t => t.ModuleId == module.Id).Select(t => t.TaskID).ToList();
+
+                    list.RemoveAll(l => currentTaskIds.Contains(l));
+                    list.RemoveAll(l => tasksIds.Contains(l));
+
+                    if (list == null || list.Count <= 0)
+                    {
+                        return new ResponseCommon<object>
+                        {
+                            Code = 201,
+                            Message = $"操作失败：同一个库位同时只能同时操作八种物料！"
+                        };
+                    }
+
+                    var taskId = list.First();
+
                     var task = new CurrentTask()
                     {
-                        StoreId = store.Id,
-                        StoreCode = store.StoreCode,
-
+                        ModuleId = module.Id,
+                        ModuleCode = module.ModuleCode,
+                        ShelfId = module.ShelfId,
+                        ShelfCode = module.ShelfCode,
                         Guid = orderDetail.Guid,
+                        ItemNo = orderDetail.ItemNo,
                         TaskMode = request.OrderType,
                         OrderNumber = request.OrderNumber,
-                        ButtonColor = request.Corlor,
+                        TaskID = taskId,
+                        ButtonColor = buttonColor,
                         MatCode = orderDetail.MatCode,
                         MatName = orderDetail.MatName,
-                        MatSpec = orderDetail.MatSpec,
+                        MatSpec = string.IsNullOrEmpty(orderDetail.MatSpec) ? "-" : orderDetail.MatSpec,
                         MatBatch = orderDetail.MatBatch,
-                        Qty = orderDetail.Qty
+                        MatSN = orderDetail.MatSN,
+                        Qty = (int)orderDetail.Qty
                     };
                     tasks.Add(task);
                 }
@@ -105,7 +176,7 @@ namespace WCS.BLL.Services.Service
                         Message = $"操作失败：{ex.Message}"
                     };
                 }
-                //发送任务至各个标签
+                //发送任务至各个标签 交给后台线程来做
                 return new ResponseCommon<object>
                 {
                     Code = 200,
@@ -116,11 +187,276 @@ namespace WCS.BLL.Services.Service
             {
                 return new ResponseCommon<object>
                 {
-                    Code = 200,
+                    Code = 201,
                     Message = "操作失败：" + ex.Message,
 
                 };
             }
         }
+
+        /// <summary>
+        /// 取消同步的任务
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public async Task<ResponseCommon<object>> cancelOrderMXL4(CancelRequest request)
+        {
+            try
+            {
+                if (request.matSN == null || request.matSN.Count <= 0)
+                {
+                    return new ResponseCommon<object>
+                    {
+                        Code = 300,
+                        Message = $"未取消需要操作的物料条码！"
+                    };
+                }
+
+                var needCancelTasks = DbHelp.db.Queryable<CurrentTask>()
+                                               .Where(t => request.matSN.Contains(t.MatSN))
+                                               .ToList();
+                needCancelTasks.ForEach(t => t.IsCancel = true);
+                //获取当前
+                try
+                {
+                    DbHelp.db.BeginTran();
+                    DbHelp.db.Updateable(needCancelTasks).ExecuteCommand();
+                    DbHelp.db.CommitTran();
+                }
+                catch (Exception ex)
+                {
+                    DbHelp.db.RollbackTran();
+                    return new ResponseCommon<object>
+                    {
+                        Code = 300,
+                        Message = $"操作失败：{ex.Message}"
+                    };
+                }
+                //发送任务至各个标签 交给后台线程来做
+                return new ResponseCommon<object>
+                {
+                    Code = 200,
+                    Message = "success"
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon<object>
+                {
+                    Code = 201,
+                    Message = "操作失败：" + ex.Message,
+
+                };
+            }
+        }
+
+        /// <summary>
+        /// 取消同步的任务-通过工单和物料编码进行取消任务
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public async Task<ResponseCommon<object>> cancelOrderByCode(CancelOrderByCodeRequest request)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(request.OrderNumber))
+                {
+                    return new ResponseCommon<object>
+                    {
+                        Code = 300,
+                        Message = $"缺少工单号！"
+                    };
+                }
+
+                var needCancelTasks = DbHelp.db.Queryable<CurrentTask>()
+                                               .Where(t => request.OrderNumber == request.OrderNumber)
+                                               .WhereIF(!string.IsNullOrEmpty(request.MatCode), t => t.ItemNo == request.MatCode)
+                                               .ToList();
+                needCancelTasks.ForEach(t => t.IsCancel = true);
+                //获取当前
+                try
+                {
+                    DbHelp.db.BeginTran();
+                    DbHelp.db.Updateable(needCancelTasks).ExecuteCommand();
+                    DbHelp.db.CommitTran();
+                }
+                catch (Exception ex)
+                {
+                    DbHelp.db.RollbackTran();
+                    return new ResponseCommon<object>
+                    {
+                        Code = 300,
+                        Message = $"操作失败：{ex.Message}"
+                    };
+                }
+                //发送任务至各个标签 交给后台线程来做
+                return new ResponseCommon<object>
+                {
+                    Code = 200,
+                    Message = "success"
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon<object>
+                {
+                    Code = 201,
+                    Message = "操作失败：" + ex.Message,
+
+                };
+            }
+        }
+
+        public async Task<ResponseCommon> refreshInventoryRequest(RefreshInventoryRequest request)
+        {
+            try
+            {
+                //第一步：校验库位在数据库中是否都存在
+                var storeCodeList = request.StoreCodes.Distinct()
+                                                .ToList();
+                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.ModuleCode))
+                                      .Select((si, sti) => si)
+                                      .ToList();
+                if (modules.Count < storeCodeList.Count)
+                {
+                    var storeCodesInDB = modules.Select(t => t.ModuleCode).ToList();
+                    storeCodeList.RemoveAll(t => storeCodesInDB.Contains(t));
+                    return new ResponseCommon
+                    {
+                        Code = 201,
+                        Message = $"操作失败：库位【{string.Join(",", storeCodeList)}】不存在！",
+                    };
+                }
+                //第二步:获取到对应货架
+                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,
+                    Message = "success"
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon
+                {
+                    Code = 201,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        public async Task<ResponseCommon> reSetAll()
+        {
+            try
+            {
+                //1.获取所有液晶标签货架
+                var shelfs = ShelfManager.Shelves.Where(t => t.ShelfTypeName == "液晶标签货架")
+                                                 .Select(t => t as MXL4Shelf)
+                                                 .ToList();
+                shelfs.ForEach(t =>
+                {
+                    t.Reset();
+                });
+                return new ResponseCommon
+                {
+                    Code = 200,
+                    Message = "success"
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon
+                {
+                    Code = 201,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        public async Task<ResponseCommon> defaultDisplay()
+        {
+            try
+            {
+                //1.获取所有液晶标签货架
+                var shelfs = ShelfManager.Shelves.Where(t => t.ShelfTypeName == "液晶标签货架")
+                                                 .Select(t => t as MXL4Shelf)
+                                                 .ToList();
+                shelfs.ForEach(t =>
+                {
+                    t.MXL4Modules.ForEach(m =>
+                    {
+                        //发送进入入库模式
+                        m.GoInOutstoreMode(t.TcpCleint, DbModels.Task.ButtonColorEnum.红色);
+                        //任务ID
+                        m.SendTaskId(7, t.TcpCleint);
+                        m.SendMatCode("A7100200300", t.TcpCleint);
+                        m.SendMatName("A7SESSSSSS", t.TcpCleint);
+                        m.SendMatSpec("7GUIGE", t.TcpCleint);
+                        m.SendMatBatch("202412097", t.TcpCleint);
+                        m.SendMatQty(999, t.TcpCleint);
+
+                        m.SendTaskId(6, t.TcpCleint);
+                        m.SendMatCode("A6666666", t.TcpCleint);
+                        m.SendMatName("ASESSSSSS6", t.TcpCleint);
+                        m.SendMatSpec("GUIGE6", t.TcpCleint);
+                        m.SendMatBatch("202412096", t.TcpCleint);
+                        m.SendMatQty(222, t.TcpCleint);
+
+                        m.SendTaskId(3, t.TcpCleint);
+                        m.SendMatCode("A33333", t.TcpCleint);
+                        m.SendMatName("3ASESSSSS", t.TcpCleint);
+                        m.SendMatSpec("3GUIGE3", t.TcpCleint);
+                        m.SendMatBatch("202412093", t.TcpCleint);
+                        m.SendMatQty(333, t.TcpCleint);
+                    });
+                });
+                return new ResponseCommon
+                {
+                    Code = 200,
+                    Message = "success"
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon
+                {
+                    Code = 200,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
     }
 }

WCS.BLL/Services/Service/OutstoreService.cs

@@ -2,6 +2,7 @@
 using SqlSugar;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.BLL.Tool;
@@ -487,7 +488,7 @@ namespace WCS.BLL.Services.Service
 
             //获取后台当前正在进行出库的订单 将出库状态反馈给前端
             var outingOrderNumbers = ShelfManager.Shelves
-                                                .Where(t => t.CurrentMode == HardWare.Mode.出库模式)
+                                                .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                                 .Select(t => t.OrderNumber)
                                                 .ToList();
             foreach (var record in records)
@@ -753,7 +754,7 @@ namespace WCS.BLL.Services.Service
                                                  .ToList();
                 var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList(); ;
 
-                var outherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).Select(t => t.ShelfCode).ToList();
+                var outherModeShelfs = shelfs.Where(t => t.CurrentMode != TaskModeEnum.待机模式).Select(t => t.ShelfCode).ToList();
                 if (outherModeShelfs != null && outherModeShelfs.Count > 0)
                 {
                     return new ResponseCommon()
@@ -1200,7 +1201,7 @@ namespace WCS.BLL.Services.Service
 
             //找到正在出对应出库单的货架
             var shelves = ShelfManager.Shelves.Where(t => t.OrderNumber == request.OrderNumber)
-                                              .Where(t => t.CurrentMode == HardWare.Mode.出库模式)
+                                              .Where(t => t.CurrentMode == TaskModeEnum.出库模式)
                                               .ToList();
 
             if (shelves == null || shelves.Count == 0)

WCS.BLL/Services/Service/SelfCheckService.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.DAL.Db;
@@ -66,7 +67,7 @@ namespace WCS.BLL.Services.Service
             foreach (var ip in cleintIps)
             {
                 var currentIdShelfs = shelfs.Where(t => t.ClientIp == ip)
-                                            .Where(t => t.CurrentMode == HardWare.Mode.待机模式)
+                                            .Where(t => t.CurrentMode == TaskModeEnum.待机模式)
                                             .ToList();
                 Task.Run(() =>
                 {

WCS.BLL/Services/Service/SingleLightService.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using TouchSocket.Core;
+using WCS.BLL.Config;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.BLL.Tool;
@@ -24,6 +25,25 @@ namespace WCS.BLL.Services.Service
 {
     public class SingleLightService : ISingleLightService
     {
+        public string ExtractUntilSecondDashCorrect(string input)
+        {
+            int firstDashIndex = input.IndexOf('-');
+            if (firstDashIndex == -1)
+            {
+                return string.Empty; // 如果没有找到第一个'-'，则返回空字符串
+            }
+
+            int secondDashIndex = input.IndexOf('-', firstDashIndex + 1);
+            if (secondDashIndex == -1)
+            {
+                return input;
+            }
+            else
+            {
+                return input.Substring(0, secondDashIndex);
+            }
+        }
+
         /// <summary>
         /// 单灯 一个库位对应一个硬件
         /// </summary>
@@ -34,7 +54,7 @@ namespace WCS.BLL.Services.Service
             try
             {
                 //传入数据校验
-                if (request.StoreList == null || request.StoreList.Count == 0)
+                if (request.StoreCodes == null || request.StoreCodes.Count == 0)
                 {
                     return new ResponseCommon<object>()
                     {
@@ -42,9 +62,19 @@ namespace WCS.BLL.Services.Service
                         Message = "操作失败：没有需要控制的库位",
                     };
                 }
+                //瓦斯分院库位数与灯不匹配所以进行如下操作
+                //处理传入的库位
+                if(!LocalFile.Config.IsZuantan)
+                {
+                    for (int i = 0; i < request.StoreCodes.Count; i++)
+                    {
+                        request.StoreCodes[i] = ExtractUntilSecondDashCorrect(request.StoreCodes[i]);
+                    }
+                }
+
+
                 //库位编码去重
-                var storeCodes = request.StoreList.Select(t => t.StoreCode)
-                                                  .Distinct()
+                var storeCodes = request.StoreCodes.Distinct()
                                                   .ToList();
                 var stores = DbHelp.db.Queryable<StoreInfo>()
                                       .Where(t => storeCodes.Contains(t.StoreCode))
@@ -63,38 +93,10 @@ namespace WCS.BLL.Services.Service
                 var shelfs = DbHelp.db.Queryable<ShelfInfo>().Where(t => shelfIds.Contains(t.Id))
                                                              .ToList();
 
-                //对应模组信息
-                var moduleIds = stores.Select(t => t.ModuleId).Distinct().ToList();
-                var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => moduleIds.Contains(t.Id))
-                                                               .ToList();
-
-                //加载请求参数中的库位灯 板子ID和货架ID
-                foreach (var store in request.StoreList)
-                {
-                    var storeInDb = stores.Where(t => t.StoreCode == store.StoreCode).FirstOrDefault();
-                    if (storeInDb == null)
-                    {
-                        return new ResponseCommon<object>
-                        {
-                            Code = 201,
-                            Message = $"操作失败：库位{store.StoreCode}不存在(store)！"
-                        };
-                    }
-                    else
-                        store.ShelfId = storeInDb.ShelfId;
-
-                    var moduleInDb = modules.Where(t => t.Id == storeInDb.ModuleId).FirstOrDefault();
-                    if (moduleInDb == null)
-                    {
-                        return new ResponseCommon<object>
-                        {
-                            Code = 201,
-                            Message = $"操作失败：库位{store.StoreCode}不存在(module)！"
-                        };
-                    }
-                    else
-                        store.BoardId = moduleInDb.BoardId;
-                }
+                ////对应模组信息
+                //var moduleIds = stores.Select(t => t.ModuleId).Distinct().ToList();
+                //var modules = DbHelp.db.Queryable<ModuleInfo>().Where(t => moduleIds.Contains(t.Id))
+                //                                               .ToList();
 
                 //合并：同一个货架的库位合并
                 var shelfModels = new List<SingleLightShelfModel>();
@@ -102,41 +104,101 @@ namespace WCS.BLL.Services.Service
                 {
                     var shelfModel = new SingleLightShelfModel();
                     //报警灯
-                    shelfModel.WarningLightMode = request.WarningLightMode;
-                    shelfModel.WarningBuzzerMode = request.WarningBuzzerMode;
-                    shelfModel.WarningLightColor = request.WarningLightColor;
+                    if (shelf.LightId > 0)
+                    {
+                        shelfModel.WarningLightMode = request.LightMode;
+                    }
+                    shelfModel.WarningLightColor = request.ColorMode;
                     shelfModel.WarningBoardId = shelf.LightId;
                     shelfModel.ClientIp = shelf.ClientIp;
-                    //库位
-                    var storesThisShelf = request.StoreList
-                                               .Where(t => t.ShelfId == shelf.Id)
-                                               .ToList();
-                    foreach (var storeThisShelf in storesThisShelf)
-                    {
-                        shelfModel.StoreList.Add(new SingleLightStoreModel()
-                        {
-                            BoardId = storeThisShelf.BoardId,
-                            LightColor = storeThisShelf.LightColor,
-                            LightMode = storeThisShelf.LightMode,
-                        });
-                    }
+
+                    shelfModel.StoreList = stores.Where(t => t.ShelfId == shelf.Id)
+                                                 .Select(t => new SingleLightStoreModel()
+                                                 {
+                                                     BoardId = t.BoardId,
+                                                     LightMode = request.LightMode,
+                                                     LightColor = request.ColorMode,
+                                                     LightNumber = t.SingleLightNumber,
+                                                 }).ToList();
+
                     shelfModels.Add(shelfModel);
                 }
 
                 //合并：同一个TCP的货架合并 报警灯和库位灯统一只发送一条指令
-                var clientIpList = shelfs.Select(t => t.ClientIp)
-                                         .Distinct()
-                                         .ToList();
-                foreach (var clientIp in clientIpList)
+                var clients = shelfs.Select(t => new
                 {
-                    var shelfModelsInOneIp = shelfModels.Where(t => t.ClientIp == clientIp).ToList();
-                    var sendData = Helper.SingleLightControl(shelfModelsInOneIp);
+                    ClientIp = t.ClientIp,
+                    IsService = t.IsService,
+                })
+                .Distinct()
+                .ToList();
+                foreach (var client in clients)
+                {
+                    var shelfModelsInOneIp = shelfModels.Where(t => t.ClientIp == client.ClientIp).ToList();
 
-                    TCPClient tCPClient = TCPClientManager.GetTCPClientByIPHost(clientIp);
-                    tCPClient.Send(sendData);
-                    Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
+                    var sendData = Helper.SingleLightControl(shelfModelsInOneIp);
+                    if (client.IsService)
+                    {
+                        TCPClient tcpClient = TCPClientManager.GetTCPClientByIPHost(client.ClientIp);
+                        if (tcpClient != null)
+                        {
+                            try
+                            {
+                                tcpClient.Send(sendData);
+                                Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+                            }
+                        }
+                        else
+                        {
+                            Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                        }
+                    }
+                    else
+                    {
+                        var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == client.ClientIp).FirstOrDefault();
+                        if (tcpClient != null)
+                        {
+                            try
+                            {
+                                tcpClient.Send(sendData, 0, sendData.Length);
+                                Logs.Write("【单灯单独控制】发送指令" + BitConverter.ToString(sendData));
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【单灯单独控制】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+                                return new ResponseCommon<object>()
+                                {
+                                    Code = 201,
+                                    Message = $"【单灯单独控制】{client}指令发送中遇到异常{ex.Message}",
+                                };
+                            }
+                        }
+                        else
+                        {
+                            Logs.Write($"【单灯单独控制】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                            return new ResponseCommon<object>()
+                            {
+                                Code = 201,
+                                Message = $"【单灯单独控制】{client}未连接，以下指令未能成功发送",
+                            };
+                        }
+                    }
                 }
 
+                //更新数据库灯的状态
+                stores.ForEach(t =>
+                {
+                    t.LightMode = request.LightMode;
+                    t.ColorMode = request.ColorMode;
+                });
+                DbHelp.db.Updateable(stores)
+                         .UpdateColumns(t => new { t.LightMode, t.ColorMode })
+                         .ExecuteCommand();
+
                 //返回成功
                 return new ResponseCommon<object>()
                 {
@@ -146,7 +208,130 @@ namespace WCS.BLL.Services.Service
             }
             catch (Exception ex)
             {
-              
+
+                //操作失败
+                return new ResponseCommon<object>()
+                {
+                    Code = 300,
+                    Message = $"操作失败：{ex.Message}",
+                };
+            }
+        }
+
+        public async Task<ResponseCommon<object>> TurnoffLightByArea(TurnoffLightByAreaRequest request)
+        {
+            try
+            {
+                //传入数据校验
+                if (string.IsNullOrEmpty(request.Area))
+                {
+                    return new ResponseCommon<object>()
+                    {
+                        Code = 201,
+                        Message = "操作失败：参数传入错误！Area为空！",
+                    };
+                }
+                //库位
+                var stores = DbHelp.db.Queryable<StoreInfo>()
+                                      .Where(t => t.Area == request.Area)
+                                      .ToList();
+                if (stores == null || stores.Count == 0)
+                {
+                    return new ResponseCommon<object>
+                    {
+                        Code = 201,
+                        Message = $"操作失败：所选区域不存在库位！"
+                    };
+                }
+
+                //对应货架（获取TCP和报警灯ID）
+                var shelfIds = stores.Select(t => t.ShelfId).Distinct().ToList();
+                var shelfs = DbHelp.db.Queryable<ShelfInfo>().Where(t => shelfIds.Contains(t.Id))
+                                                             .ToList();
+                //获取对应货架所有IP
+                var clients = shelfs.Select(t => new
+                {
+                    ClientIp = t.ClientIp,
+                    IsService = t.IsService,
+                })
+                .Distinct()
+                .ToList();
+
+                //挨个发关灯指令
+                foreach (var client in clients)
+                {
+                    //生成关灯指令
+                    var sendData = Helper.SingleLightTrunOffAllLight();
+
+                    if (client.IsService)
+                    {
+                        TCPClient tcpClient = TCPClientManager.GetTCPClientByIPHost(client.ClientIp);
+                        if (tcpClient != null)
+                        {
+                            try
+                            {
+                                tcpClient.Send(sendData);
+                                Logs.Write("【熄灯】发送指令" + BitConverter.ToString(sendData));
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【熄灯】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+                            }
+                        }
+                        else
+                        {
+                            Logs.Write($"【熄灯】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                        }
+                    }
+                    else
+                    {
+                        var tcpClient = TCPClientManager.Service.GetClients().Where(t => t.IP + ":" + t.Port.ToString() == client.ClientIp).FirstOrDefault();
+                        if (tcpClient != null)
+                        {
+                            try
+                            {
+                                tcpClient.Send(sendData, 0, sendData.Length);
+                                Logs.Write("【熄灯】发送指令" + BitConverter.ToString(sendData));
+                            }
+                            catch (Exception ex)
+                            {
+                                Logs.Write($"【熄灯】{client}以下指令发送中遇到异常{ex.Message}" + BitConverter.ToString(sendData));
+
+                            }
+                        }
+                        else
+                        {
+                            Logs.Write($"【熄灯】{client}未连接，以下指令未能成功发送" + BitConverter.ToString(sendData));
+                            return new ResponseCommon<object>()
+                            {
+                                Code = 201,
+                                Message = $"【熄灯】{client}未连接，以下指令未能成功发送",
+                            };
+                        }
+                    }
+                }
+
+                //更新灯状态为熄灭
+                //var stores = DbHelp.db.Queryable<StoreInfo>().Where(t => t.Area == request.Area).ToList();
+                stores.ForEach(t =>
+                {
+                    t.ColorMode = 0;
+                    t.LightMode = 0;
+                });
+                DbHelp.db.Updateable(stores)
+                         .UpdateColumns(t => new { t.LightMode, t.ColorMode })
+                         .ExecuteCommand();
+
+                //返回成功
+                return new ResponseCommon<object>()
+                {
+                    Code = 200,
+                    Message = "success",
+                };
+            }
+            catch (Exception ex)
+            {
+
                 //操作失败
                 return new ResponseCommon<object>()
                 {

WCS.BLL/Services/Service/StockTakingService.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Threading.Tasks;
 using WCS.BLL.Config;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.DAL.Db;
@@ -566,7 +567,7 @@ namespace WCS.BLL.Services.Service
                                  .ToList();
                 var shelfs = ShelfManager.Shelves.Where(t => shelfIds.Contains(t.ShelfId)).ToList(); ;
 
-                var outherModeShelfs = shelfs.Where(t => t.CurrentMode != HardWare.Mode.待机模式).Select(t => t.ShelfCode).ToList();
+                var outherModeShelfs = shelfs.Where(t => t.CurrentMode != TaskModeEnum.待机模式).Select(t => t.ShelfCode).ToList();
                 if (outherModeShelfs != null && outherModeShelfs.Count > 0)
                 {
                     return new ResponseCommon()
@@ -651,7 +652,7 @@ namespace WCS.BLL.Services.Service
                 #endregion
 
                 #region 查询当前盘点单 已启动的货架
-                var shelfs = ShelfManager.Shelves.Where(t => t.CurrentMode == HardWare.Mode.盘点模式 && t.OrderNumber == order.StocktakingOrderNumber).ToList();
+                var shelfs = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.盘点模式 && t.OrderNumber == order.StocktakingOrderNumber).ToList();
                 shelfs.ForEach(t =>
                 {
                     t.GoOutStocktaking();
@@ -704,7 +705,7 @@ namespace WCS.BLL.Services.Service
                     Message = $"货架{inventoryDetail.ShelfCode}不存在！",
                 };
             }
-            else if (shelf.CurrentMode != HardWare.Mode.盘点模式)
+            else if (shelf.CurrentMode != TaskModeEnum.盘点模式)
             {
                 return new ResponseCommon()
                 {
@@ -787,7 +788,7 @@ namespace WCS.BLL.Services.Service
                         Message = $"货架{stockTakingMatDetail.StoreInfo.ShelfCode}不存在！",
                     };
                 }
-                else if (shelf.CurrentMode != HardWare.Mode.盘点模式)
+                else if (shelf.CurrentMode != TaskModeEnum.盘点模式)
                 {
                     DbHelp.db.RollbackTran();
                     return new ResponseCommon()
@@ -826,7 +827,7 @@ namespace WCS.BLL.Services.Service
                 //更新时间 避免被自动退出
                 Task.Run(() =>
                 {
-                    var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == HardWare.Mode.盘点模式 && t.OrderNumber == request.StocktakingOrderNumber)
+                    var shelves = ShelfManager.Shelves.Where(t => t.CurrentMode == TaskModeEnum.盘点模式 && t.OrderNumber == request.StocktakingOrderNumber)
                                                       .ToList();
                     foreach (var shelf in shelves)
                     {

WCS.BLL/Tool/Api/ApiHelp.cs

@@ -12,6 +12,7 @@ using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Input;
 using WCS.BLL;
+using WCS.BLL.Config;
 using WCS.Model;
 
 namespace WCS.BLL.Tool
@@ -280,6 +281,7 @@ namespace WCS.BLL.Tool
                 if (isSaveLog)
                     Logs.Write($"【{guid}】开始请求调用接口   url：{url}   请求方式：{httpMethod}   数据：{data}", LogsType.Api);
                 HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+                request.Headers.Add("token",LocalStatic.WMSToken);//智能制造要求请求增加token
                 request.Method = httpMethod;
                 request.ContentType = "application/json";
                 request.Timeout = 10000;
@@ -324,7 +326,7 @@ namespace WCS.BLL.Tool
                 HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                 request.Method = httpMethod;
                 request.ContentType = "application/json";
-                request.Timeout = 2000;
+                request.Timeout = 5000;
 
                 if (!string.IsNullOrEmpty(data))
                 {

WCS.BLL/Tool/Helper.cs

@@ -352,6 +352,19 @@ namespace WCS.BLL.Tool
             var lightCount = 0;
             foreach (var shelf in shelfs)
             {
+                //库位灯指令
+                if (shelf.StoreList != null && shelf.StoreList.Count > 0)
+                {
+                    foreach (var store in shelf.StoreList)
+                    {
+                        for (int i = 0; i < store.LightNumber; i++)
+                        {
+                            var singleLightData = GenerateSingleLightData(store.BoardId + i, store.LightMode, store.LightColor);
+                            lightCount++;
+                            dataBase = dataBase.Concat(singleLightData).ToArray();
+                        }
+                    }
+                }
                 //6个报警灯需要发送指令
 
                 if (shelf.WarningLightMode != -1)
@@ -364,23 +377,14 @@ namespace WCS.BLL.Tool
                     }
                 }
                 //蜂鸣器需要发送指令
-                if (shelf.WarningBuzzerMode != -1)
-                {
-                    var singleLightData = GenerateSingleLightData(shelf.WarningBoardId + 6, shelf.WarningBuzzerMode, shelf.WarningLightColor);
-                    lightCount++;
-                    dataBase = dataBase.Concat(singleLightData).ToArray();
-                }
+                //if (shelf.WarningLightMode == 3)//单灯短亮一次的情况下 蜂鸣器短鸣一次
+                //{
+                //    var singleLightData = GenerateSingleLightData(shelf.WarningBoardId + 6, 3, shelf.WarningLightColor);
+                //    lightCount++;
+                //    dataBase = dataBase.Concat(singleLightData).ToArray();
+                //}
+
 
-                //库位灯指令
-                if (shelf.StoreList != null && shelf.StoreList.Count > 0)
-                {
-                    foreach (var store in shelf.StoreList)
-                    {
-                        var singleLightData = GenerateSingleLightData(store.BoardId, store.LightMode, store.LightColor);
-                        lightCount++;
-                        dataBase = dataBase.Concat(singleLightData).ToArray();
-                    }
-                }
             }
 
             byte[] length_base = BitConverter.GetBytes(dataBase.Length + 2);
@@ -408,7 +412,7 @@ namespace WCS.BLL.Tool
         {
             public string ClientIp { get; set; } = string.Empty;
             public int WarningBoardId { get; set; }
-            public int WarningLightMode { get; set; }
+            public int WarningLightMode { get; set; } = -1;
             public int WarningBuzzerMode { get; set; }
             public int WarningLightColor { get; set; }
             public List<SingleLightStoreModel> StoreList { get; set; } = new List<SingleLightStoreModel>();
@@ -419,6 +423,27 @@ namespace WCS.BLL.Tool
             public int BoardId { get; set; }
             public int LightMode { get; set; }
             public int LightColor { get; set; }
+
+            /// <summary>
+            /// 单灯存在大库位灯 每个库位可能不止一个灯 故加此字段
+            /// </summary>
+            public int LightNumber { get; set; } = 1;
+        }
+
+        //单灯货架全部灭灯
+        public static byte[] SingleLightTrunOffAllLight()
+        {
+            byte[] dataBase = new byte[8];
+            dataBase[0] = 0xff;
+            dataBase[1] = 0x01;
+            dataBase[2] = 0x00;
+            dataBase[3] = 0x0A;
+            dataBase[4] = 0xff;
+            dataBase[5] = 0xff;
+            dataBase[6] = 0x00;
+            dataBase[7] = 0x00;
+            byte[] dataWithCRC = Crc16(dataBase, dataBase.Length, true);
+            return dataWithCRC;
         }
 
         /// <summary>

WCS.BLL/Tool/TCPClient.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Concurrent;
 using System.ComponentModel.Design;
+using System.Reflection;
 using System.Text;
+using System.Text.RegularExpressions;
 using TouchSocket.Core;
 using TouchSocket.Sockets;
 using WCS.BLL.Tool;
@@ -19,8 +21,8 @@ namespace WCS.BLL
         public string BindIPHost { get; set; } = "127.0.0.1:20003";
 
         public string ShelfTypeName { get; set; }
-        public bool IsOnline { get; set; } = false;
-
+        public bool IsReceivedClientOnline { get; set; } = false;
+        public bool IsSendClientOnline { get; set; } = false;
         //第一次连接是否已连接
         public bool IsFirstConnected { get; set; } = false;
 
@@ -31,9 +33,13 @@ namespace WCS.BLL
         //协议数据部分长度
         public readonly int DataLength = 10;
 
-        public ConcurrentDictionary<int, MessageDto> MessageList { get; set; } = new ConcurrentDictionary<int, MessageDto>();
 
-        public TcpClient tcpClient { get; set; }
+        public TcpClient tcpSendClient { get; set; }
+
+        //同步发送等待客户端 等待上一条指令发送成功并收到响应之后才发送下一条指令
+        public IWaitingClient<TcpClient> waitClient;
+
+        public TcpClient tcpReceiveClient { get; set; }
 
         public object receivdLockObject = new object();
         public object sendLockObject = new object();
@@ -42,7 +48,8 @@ namespace WCS.BLL
         {
             try
             {
-                tcpClient.Connect();//调用连接，当连接不成功时，会抛出异常。
+                tcpSendClient.Connect();//调用连接，当连接不成功时，会抛出异常。
+                tcpReceiveClient.Connect();
                 return true;
             }
             catch (Exception e)
@@ -64,14 +71,15 @@ namespace WCS.BLL
                 BindIPHost = bindIPHost;
                 ShelfTypeName = shelfTypeName;
 
-                tcpClient = new TcpClient();
+                tcpSendClient = new TcpClient();
+                tcpReceiveClient = new TcpClient();
+
 
                 if (string.IsNullOrEmpty(BindIPHost))
                 {
                     //载入配置
-                    tcpClient.Setup(new TouchSocketConfig()
+                    tcpSendClient.Setup(new TouchSocketConfig()
                         .SetRemoteIPHost(new IPHost(RemoteIPHost))
-                        //.SetBindIPHost(BindIPHost)
                         .ConfigurePlugins(a =>
                         {
                             //配置断线重连
@@ -83,11 +91,39 @@ namespace WCS.BLL
                             //添加控制台日志注入
                             a.AddConsoleLogger();
                         }));
+
+                    waitClient = tcpSendClient.CreateWaitingClient(new WaitingOptions()
+                    {
+                        FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
+                        {
+                            if (response.Data.Length == 13)
+                            {
+                                return true;
+                            }
+                            return false;
+                        }
+                    });
+
+                    tcpReceiveClient.Setup(new TouchSocketConfig()
+    .SetRemoteIPHost(new IPHost(RemoteIPHost))
+    //.SetBindIPHost(BindIPHost)
+    .ConfigurePlugins(a =>
+    {
+        //配置断线重连
+        a.UseReconnection(-1, true, 1000);
+        a.Add<HeartbeatAndReceivePlugin>();
+    })
+    .ConfigureContainer(a =>
+    {
+        //添加控制台日志注入
+        a.AddConsoleLogger();
+    }));
+
                 }
                 else
                 {
                     //载入配置
-                    tcpClient.Setup(new TouchSocketConfig()
+                    tcpSendClient.Setup(new TouchSocketConfig()
                         .SetRemoteIPHost(new IPHost(RemoteIPHost))
                         .SetBindIPHost(new IPHost(BindIPHost))
                         .ConfigurePlugins(a =>
@@ -101,124 +137,110 @@ namespace WCS.BLL
                             //添加控制台日志注入
                             a.AddConsoleLogger();
                         }));
+
+                    waitClient = tcpSendClient.CreateWaitingClient(new WaitingOptions()
+                    {
+                        FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
+                        {
+                            if (response.Data.Length == 13)
+                            {
+                                return true;
+                            }
+                            return false;
+                        }
+                    });
+
+                    tcpReceiveClient.Setup(new TouchSocketConfig()
+   .SetRemoteIPHost(new IPHost(RemoteIPHost))
+   //.SetBindIPHost(BindIPHost)
+   .ConfigurePlugins(a =>
+   {
+       //配置断线重连
+       a.UseReconnection(-1, true, 1000);
+       a.Add<HeartbeatAndReceivePlugin>();
+   })
+   .ConfigureContainer(a =>
+   {
+       //添加控制台日志注入
+       a.AddConsoleLogger();
+   }));
                 }
 
                 //添加接收事件 匹配已发送的指令
-                tcpClient.Received += (client, e) =>
-                {
-                    var data = e.ByteBlock.Buffer.Take((int)e.ByteBlock.Length).ToArray();
-                    Task.Run(() =>
-                    {
-                        Logs.Write($"【校验发送接收 开始】{ShelfTypeName}" + BitConverter.ToString(data), LogsType.InstructionResend);
-                        if (ShelfTypeName == "信息化货架")
-                        {
-                            //协议拆包
-                            var len = data.Length;
-                            //灯控制统一返回的是 FF-00-00-0A-00-02-D7-B5
-                            if (len == 8)
-                            {
-                                if (data[4] == 0x00 && data[0] == 0xFF && data[1] == 0x00 && (data[5] == 0x01 || data[5] == 0x02))
-                                {
-                                    //查询当前板子是否有待验证的指令
-                                    var message = new MessageDto();
-                                    var firstMessage = MessageList.Select(t => new { Id = t.Key, Value = t.Value })
-                                                                  .OrderBy(t => t.Value.CreateTime)
-                                                                  .First();
-                                    if (firstMessage != null)
-                                    {
-                                        MessageList.TryRemove(firstMessage.Id, out message);
-                                        Logs.Write($"【信息化货架】以下指令已不重发：{BitConverter.ToString(firstMessage.Value.Message)}", LogsType.InstructionResend);
-                                    }
-                                }
-                            }
-                        }
-                        else if (ShelfTypeName == "液晶货架")
-                        {
-                            Logs.Write($"【液晶货架】接收到指令{BitConverter.ToString(data)}", LogsType.InstructionResend);
-                        }
-                        //智能货架
-                        else
-                        {
-                            var len = data.Length;
-                            for (int index = 0; index < data.Length - PreFixLength; index++)
-                            {
-                                //协议拆包 通过前缀校验是否为完整数据包
-                                var prefixInData = data.Skip(index).Take(PreFixLength);
-                                var isEqual = prefixInData.SequenceEqual(Prefix);
-                                if (isEqual)
-                                {
-                                    var dataTemp = data.Skip(index).Take(PreFixLength + DataLength).ToArray();
-                                    if (dataTemp.Length < PreFixLength + DataLength)//拆包后不满足一条指令的长度
-                                    {
-                                        continue;
-                                    }
-                                    //获取返回指令的板子ID
-                                    var boardId = (dataTemp[PreFixLength + 0] << 8) + dataTemp[PreFixLength + 1];
-                                    //查询当前板子是否有待验证的指令
-                                    var message = new MessageDto();
-                                    MessageList.TryGetValue(boardId, out message);
-                                    //功能位校验 功能位相同视为已响应指令 删除对应的指令
-                                    if (message?.Message[PreFixLength + 2] == dataTemp[PreFixLength + 2])
-                                    {
-                                        MessageList.TryRemove(boardId, out message);
-                                    }
-                                    index += (PreFixLength + DataLength - 2);//每次循环index会+1 所以这里-1
-                                }
-                            }
-                        }
-                        Logs.Write($"【校验发送接收 结束】{ShelfTypeName}" + BitConverter.ToString(data), LogsType.InstructionResend);
-                    });
-                    return null;
-                };
+                //tcpReceiveClient.Received += (client, e) =>
+                //{
+                //    var data = e.ByteBlock.Buffer.Take((int)e.ByteBlock.Length).ToArray();
+                //    Task.Run(() =>
+                //    {
+                //        Logs.Write($"【校验发送接收 开始】{ShelfTypeName}" + BitConverter.ToString(data), LogsType.InstructionResend);
+                //        if (ShelfTypeName == "信息化货架")
+                //        {
+                //            //协议拆包
+                //            var len = data.Length;
+                //            //灯控制统一返回的是 FF-00-00-0A-00-02-D7-B5
+                //            if (len == 8)
+                //            {
+                //                if (data[4] == 0x00 && data[0] == 0xFF && data[1] == 0x00 && (data[5] == 0x01 || data[5] == 0x02))
+                //                {
 
-                tcpClient.Connected += (client, e) =>
+                //                }
+                //            }
+                //        }
+                //        else if (ShelfTypeName == "液晶标签货架")
+                //        {
+                //            Logs.Write($"【液晶标签货架】接收到指令{BitConverter.ToString(data)}", LogsType.InstructionResend);
+                //        }
+                //        //智能货架
+                //        else
+                //        {
+                //            var len = data.Length;
+                //            for (int index = 0; index < data.Length - PreFixLength; index++)
+                //            {
+                //                //协议拆包 通过前缀校验是否为完整数据包
+                //                var prefixInData = data.Skip(index).Take(PreFixLength);
+                //                var isEqual = prefixInData.SequenceEqual(Prefix);
+                //                if (isEqual)
+                //                {
+                //                    var dataTemp = data.Skip(index).Take(PreFixLength + DataLength).ToArray();
+                //                    if (dataTemp.Length < PreFixLength + DataLength)//拆包后不满足一条指令的长度
+                //                    {
+                //                        continue;
+                //                    }
+                //                    //获取返回指令的板子ID
+                //                    var boardId = (dataTemp[PreFixLength + 0] << 8) + dataTemp[PreFixLength + 1];
+                //                    index += (PreFixLength + DataLength - 2);//每次循环index会+1 所以这里-1
+                //                }
+                //            }
+                //        }
+                //        Logs.Write($"【校验发送接收 结束】{ShelfTypeName}" + BitConverter.ToString(data), LogsType.InstructionResend);
+                //    });
+                //    return null;
+                //};
+
+                tcpSendClient.Connected += (client, e) =>
                 {
-                    this.IsOnline = true;
+                    this.IsSendClientOnline = true;
                     return EasyTask.CompletedTask;
                 };
 
-                tcpClient.Disconnected += (client, e) =>
+                tcpSendClient.Disconnected += (client, e) =>
                 {
-                    this.IsOnline = false;
+                    this.IsSendClientOnline = false;
                     return EasyTask.CompletedTask;
                 };
 
-                //配置数据重发机制
-                Task.Run(async () =>
+                tcpReceiveClient.Connected += (client, e) =>
                 {
-                    while (true)
-                    {
-                        try
-                        {
-                            //TODO如果指令已发两次 则取消重发
-                            await Task.Delay(100);
-                            if (MessageList.Count > 0)
-                            {
-                                var failedMessage = MessageList.Where(t => t.Value.LastSendTime < DateTime.Now.AddSeconds(-1))
-                                                               .ToList();
-                                foreach (var message in failedMessage)
-                                {
-                                    Logs.Write("【指令重发】" + BitConverter.ToString(message.Value.Message) + "指令超时1s未响应", LogsType.InstructionResend);
-                                }
-                                MessageList.RemoveWhen(t => t.Value.SendTimes >= 2);
-                                foreach (var item in MessageList)
-                                {
-                                    if (item.Value.LastSendTime < DateTime.Now.AddSeconds(-1))
-                                    {
+                    this.IsReceivedClientOnline = true;
+                    return EasyTask.CompletedTask;
+                };
 
-                                        Send(item.Value.Message);
-                                        item.Value.SendTimes++;
-                                        item.Value.LastSendTime = DateTime.Now;
-                                        Logs.Write("【指令重发】" + BitConverter.ToString(item.Value.Message) + "已进行重发", LogsType.InstructionResend);
-                                    }
-                                }
-                            }
-                        }
-                        catch
-                        {
-                        }
-                    }
-                });
+                tcpReceiveClient.Disconnected += (client, e) =>
+                {
+                    this.IsReceivedClientOnline = false;
+                    ReConnectAsync();
+                    return EasyTask.CompletedTask;
+                };
             }
             catch (Exception ex)
             {
@@ -227,7 +249,10 @@ namespace WCS.BLL
 
         public void ReConnectAsync()
         {
-            tcpClient.TryConnectAsync();
+            if (IsSendClientOnline == false)
+                tcpSendClient.TryConnectAsync();
+            if (IsReceivedClientOnline == false)
+                tcpReceiveClient.TryConnectAsync();
         }
 
 
@@ -237,25 +262,15 @@ namespace WCS.BLL
             {
                 var boardId = (message[3] << 8) + message[4];
 
-                if (boardId != 2047 && IsReSend == false)
-                {
-                    MessageList.TryAdd(boardId, new MessageDto()
-                    {
-                        ID = boardId,
-                        Message = message,
-                        SendTimes = 1
-                    });
-                }
-
                 lock (sendLockObject)
                 {
-                        tcpClient.Send(message);
+                    tcpReceiveClient.Send(message);
 
-                        var clientIpHost = tcpClient.IP + ":" + tcpClient.Port;
-                        Logs.Write($"【发送{clientIpHost}】{BitConverter.ToString(message)}", LogsType.Instructions);
+                    var clientIpHost = tcpReceiveClient.IP + ":" + tcpReceiveClient.Port;
+                    Logs.Write($"【发送{clientIpHost}】{BitConverter.ToString(message)}", LogsType.Instructions);
 
-                        //发送自带15ms间隔
-                        Thread.Sleep(18);
+                    //发送自带10ms间隔
+                    Thread.Sleep(10);
                 }
             }
             catch (Exception ex)
@@ -264,6 +279,98 @@ namespace WCS.BLL
                 //因异常断连时（网线已经被断了） 手动重连一次
                 if (ex is NotConnectedException)
                 {
+                    IsReceivedClientOnline = false;
+                    Task.Run(() =>
+                    {
+                        ReConnectAsync();
+                    });
+                }
+                throw ex;
+            }
+        }
+
+        public void SendList(List<byte[]> messages, bool IsReSend = false)
+        {
+            try
+            {
+                lock (sendLockObject)
+                {
+                    foreach (var message in messages)
+                    {
+                        var clientIpHost = tcpSendClient.IP + ":" + tcpSendClient.Port;
+                        Logs.Write($"【发送{clientIpHost}】{BitConverter.ToString(message)}", LogsType.Instructions);
+                        tcpReceiveClient.Send(message);
+                        Thread.Sleep(3);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logs.Write("【发送指令时发生异常】" + ex.Message, LogsType.Instructions);
+                //因异常断连时（网线已经被断了） 手动重连一次
+                if (ex is NotConnectedException)
+                {
+                    IsReceivedClientOnline = false;
+                    Task.Run(() =>
+                    {
+                        ReConnectAsync();
+                    });
+                }
+                throw ex;
+            }
+        }
+
+        public void SendThenReturn(byte[] message, bool IsReSend = false)
+        {
+            try
+            {
+                lock (sendLockObject)
+                {
+                    var clientIpHost = tcpSendClient.IP + ":" + tcpSendClient.Port;
+                    Logs.Write($"【同步等待发送{clientIpHost}】{BitConverter.ToString(message)}", LogsType.Instructions);
+
+                    waitClient.SendThenReturn(message);
+                    Thread.Sleep(3);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logs.Write("【同步等待发送指令时发生异常】" + ex.Message, LogsType.Instructions);
+                //因异常断连时（网线已经被断了） 手动重连一次
+                if (ex is NotConnectedException)
+                {
+                    IsSendClientOnline = false;
+                    Task.Run(() =>
+                    {
+                        ReConnectAsync();
+                    });
+                }
+                throw ex;
+            }
+        }
+
+        public void SendThenReturnList(List<byte[]> messages, bool IsReSend = false)
+        {
+            try
+            {
+                lock (sendLockObject)
+                {
+                    foreach (var message in messages)
+                    {
+                        var clientIpHost = tcpSendClient.IP + ":" + tcpSendClient.Port;
+                        Logs.Write($"【同步等待发送{clientIpHost}】{BitConverter.ToString(message)}", LogsType.Instructions);
+                        waitClient.SendThenReturn(message);
+                        Thread.Sleep(3);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logs.Write("【同步等待发送指令时发生异常】" + ex.Message, LogsType.Instructions);
+                //因异常断连时（网线已经被断了） 手动重连一次
+                if (ex is NotConnectedException)
+                {
+                    IsSendClientOnline = false;
                     Task.Run(() =>
                     {
                         ReConnectAsync();
@@ -293,26 +400,97 @@ namespace WCS.BLL
             return message;
         }
 
+        public List<byte[]> GenerateMessageList(int boardId, byte[] data, string message)
+        {
+            var list = new List<byte[]>();
+            ////去除不满足ASCII的数据
+            //message = Regex.Replace(message, @"[^\u0000-\u007F]+", string.Empty);
+            ////总共发的数据位数
+            //data[1] = Convert.ToByte(message.Length);
+            ////数据发送总帧数
+            //var messageCount = Math.Ceiling((decimal)message.Length / 6);
+            //for (int i = 0; i < messageCount; i++)
+            //{
+            //    var tempmessage = string.Empty;
+            //    //不是最后一条指令
+            //    if (i != messageCount - 1)
+            //    {
+            //        tempmessage = message.Substring(i * 6, 6);
+            //        var charArray = tempmessage.ToCharArray();
+            //        for (int index = 0; index < 6; index++)
+            //        {
+            //            data[2 + index] = Convert.ToByte(charArray[index]);
+            //        }
+            //    }
+            //    //最后一条指令
+            //    else
+            //    {
+            //        tempmessage = message.Substring(i * 6, message.Length % 6 == 0 ? 6 : message.Length % 6);
+            //        var charArray = tempmessage.ToCharArray();
+            //        //先把所有数据位置为0
+            //        for (int index = 0; index < 6; index++)
+            //        {
+            //            data[2 + index] = 0x00;
+            //        }
+            //        //有数据的置为对应的数据
+            //        for (int index = 0; index < charArray.Length; index++)
+            //        {
+            //            data[2 + index] = Convert.ToByte(charArray[index]);
+            //        }
+            //    }
+            //    list.Add(GenerateMessage(boardId, data));
+            //}
+
+            //var dataBtyes = Encoding.GetEncoding(936).GetBytes(message);
+
+            var dataBtyes = Encode.Encode.GetGb2312(message);
+            data[1] = Convert.ToByte(dataBtyes.Length);
+            var messageCount = Math.Ceiling((decimal)dataBtyes.Length / 6);
+            for (int i = 0; i < messageCount; i++)
+            {
+                byte[] charArray = dataBtyes.Skip(i * 6).Take(6).ToArray();
+                //不是最后一条指令
+                if (i != messageCount - 1)
+                {
+                    for (int index = 0; index < 6; index++)
+                    {
+                        data[2 + index] = charArray[index];
+                    }
+                }
+                //最后一条指令
+                else
+                {
+                    //先把所有数据位置为0
+                    for (int index = 0; index < 6; index++)
+                    {
+                        data[2 + index] = 0x00;
+                    }
+                    //有数据的置为对应的数据
+                    for (int index = 0; index < charArray.Length; index++)
+                    {
+                        data[2 + index] = charArray[index];
+                    }
+                }
+                list.Add(GenerateMessage(boardId, data));
+            }
+
+            return list;
+        }
+
+        private string CharToAscii(char chr)
+        {
+            return ((int)chr).ToString("X").PadLeft(2, '0');
+        }
+
+        private byte[] StrToToHexByte(string hexString)
+        {
+            hexString = hexString.Replace(" ", string.Empty);
+            if ((hexString.Length % 2) != 0)
+                hexString = "0" + hexString;
+            byte[] returnBytes = new byte[hexString.Length / 2];
+            for (int i = 0; i < returnBytes.Length; i++)
+                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
+            return returnBytes;
+        }
     }
-
-    //发送指令的记录
-    public class MessageDto
-    {
-        public int ID { get; set; }
-        /// <summary>
-        /// 最后一次发送时间
-        /// </summary>
-        public DateTime LastSendTime { get; set; } = DateTime.Now;
-
-        public DateTime CreateTime { get; set; } = DateTime.Now;
-        /// <summary>
-        /// 发送内容
-        /// </summary>
-        public byte[] Message { get; set; }
-        /// <summary>
-        /// 发送次数
-        /// </summary>
-        public int SendTimes { get; set; } = 0;//第几次发送
-    }
-
 }

WCS.BLL/WCS.BLL.csproj

@@ -7,12 +7,14 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="9.0.0" />
     <PackageReference Include="TouchSocket" Version="2.0.11" />
     <PackageReference Include="TouchSocket.Http" Version="2.0.3" />
     <PackageReference Include="XLParser" Version="1.7.2" />
   </ItemGroup>
 	
   <ItemGroup>
+    <ProjectReference Include="..\Encode\Encode.csproj" />
     <ProjectReference Include="..\WCS.DAL\WCS.DAL.csproj" />
     <ProjectReference Include="..\WCS.Model\WCS.Model.csproj" />
   </ItemGroup>

WCS.DAL/DbPath.cs

@@ -10,10 +10,12 @@ namespace WCS.DAL
     {
         public static readonly string AppDir = AppDomain.CurrentDomain.BaseDirectory;
 
-        public static readonly string LogDbPath = Path.Combine(AppDir, "data\\log.db3");
+        public static readonly string DataPath = Path.Combine(AppDir, "data");
 
-        public static readonly string DataDbPath = Path.Combine(AppDir, "data\\data.db3");
+        public static readonly string LogDbPath = Path.Combine(DataPath, "log.db3");
 
-        public static readonly string AuthDbPath = Path.Combine(AppDir, "data\\auth.db3");
+        public static readonly string DataDbPath = Path.Combine(DataPath, "data.db3");
+
+        public static readonly string AuthDbPath = Path.Combine(DataPath, "auth.db3");
     }
 }

WCS.Model/ApiModel/Home/SetBoardIdRequest.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.Home
+{
+    public class SetBoardIdRequest
+    {
+        public string IPPort { get; set; }
+        public int StartId { get; set; }
+    }
+}

WCS.Model/ApiModel/MKYBackgroundThread/StockQueryRequest.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.MKYBackgroundThread
+{
+    public class StockQueryRequest
+    {
+        public List<string> storeCodes { get; set; } = new List<string>();
+    }
+}

WCS.Model/ApiModel/MKYBackgroundThread/StockQueryResponse.cs

@@ -0,0 +1,38 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.MKYBackgroundThread
+{
+    /// <summary>
+    /// 库存查询返回实体
+    /// </summary>
+    public class StockQueryResponse
+    {
+        public int code { get; set; }
+
+        public string data { get; set; }
+
+        public string message { get; set; }
+    }
+
+    public class StockQueryResponseDataItem
+    {
+        public string batch_no { get; set; } = "-";
+
+        public string location_code { get; set; } = "-";
+
+        public decimal qty { get; set; } = 0;
+
+        public string material_name { get; set; } = "-";
+
+        public string material_code { get; set; } = "-";
+
+        /// <summary>
+        /// 物料规格
+        /// </summary>
+        [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
+        public string material_spec { get; set; } = "-";
+    }
+}

WCS.Model/ApiModel/MKYBackgroundThread/SysOrderRequest.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.MKYBackgroundThread
+{
+    public class SysOrderRequest
+    {
+        public string itemNo { get; set; }
+
+
+        public string guid { get; set; }
+
+
+        public string matCode { get; set; }
+
+
+        public string matBatch { get; set; }
+
+
+        public string matSN { get; set; }
+
+
+        public string orderNumber { get; set; }
+
+
+        public int orderType { get; set; }
+
+
+        public string storeCode { get; set; }
+
+
+        public int qty { get; set; }
+    }
+}

WCS.Model/ApiModel/MKYBackgroundThread/SysOrderResponse.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.MKYBackgroundThread
+{
+    public class SysOrderResponse
+    {
+        public int code { get; set; }
+        public string message { get; set; }
+        public object data { get; set; }
+    }
+
+    public class LoginRequest
+    {
+        public string userName { get; set; } = "cmeimZtwcs";
+        public string password { get; set; } = "Cmeim@ztwcs2024!@#";
+    }
+
+    public class LoginResponse
+    {
+        public int code { get; set; }
+        public string message { get; set; }
+        public string data { get; set; }
+    }
+}

WCS.Model/ApiModel/MXL4/RefreshInventoryRequest.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using WCS.BLL.DbModels.Task;
+
+namespace WCS.Model.ApiModel.MXL4
+{
+    /// <summary>
+    /// 刷新库位库存显示信息请求实体
+    /// </summary>
+    public class RefreshInventoryRequest : RequestBase
+    {
+        public List<string> StoreCodes { get; set; }
+    }
+}

WCS.Model/ApiModel/MXL4/SysOrderMXL4Request.cs

@@ -5,13 +5,31 @@ using WCS.BLL.DbModels.Task;
 
 namespace WCS.Model.ApiModel.MXL4
 {
+    public class CancelRequest : RequestBase
+    {
+        public List<string> matSN { get; set; }
+    }
+
+    public class CancelOrderByCodeRequest : RequestBase
+    {
+        /// <summary>
+        /// 单据号
+        /// </summary>
+        public string OrderNumber { get; set; }
+
+        /// <summary>
+        /// 物料编码
+        /// </summary>
+        public string MatCode { get; set; }
+    }
+
     public class SysOrderMXL4Request : RequestBase
     {
 
         /// <summary>
         /// 按钮颜色
         /// </summary>
-        public ButtonColorEnum Corlor { get; set; }
+        public string Corlor { get; set; }
 
         /// <summary>
         /// 任务单号
@@ -36,6 +54,11 @@ namespace WCS.Model.ApiModel.MXL4
         /// </summary>
         public Guid Guid { get; set; }
 
+        /// <summary>
+        ///系统那边的主键
+        /// </summary>
+        public string ItemNo { get; set; }
+
         /// <summary>
         /// 库位编码
         /// </summary>
@@ -44,26 +67,31 @@ namespace WCS.Model.ApiModel.MXL4
         /// <summary>
         /// 物料编码
         /// </summary>
-        public string MatCode { get; set; }
+        public string MatCode { get; set; } = "-";
 
         /// <summary>
         /// 物料名称
         /// </summary>
-        public string MatName { get; set; }
+        public string MatName { get; set; } = "-";
 
         /// <summary>
         /// 物料规格
         /// </summary>
-        public string MatSpec { get; set; }
+        public string MatSpec { get; set; } = "-";
 
         /// <summary>
         /// 物料批次
         /// </summary>
-        public string MatBatch { get; set; }
+        public string MatBatch { get; set; } = "-";
+
+        /// <summary>
+        /// 物料SN
+        /// </summary>
+        public string MatSN { get; set; }
 
         /// <summary>
         /// 数量
         /// </summary>
-        public int Qty { get; set; }
+        public decimal Qty { get; set; }
     }
 }

WCS.Model/ApiModel/MXL4/TaskEnum.cs

@@ -22,8 +22,9 @@ namespace WCS.BLL.DbModels.Task
 
     public enum TaskModeEnum
     {
-        入库模式 = 0,
-        出库模式 = 1,
-        盘点模式 = 2
+        入库模式 = 1,
+        出库模式 = 2,
+        盘点模式 = 3,
+        待机模式 = 0
     }
 }

WCS.Model/ApiModel/SingleLight/SingleLightControlRequest.cs

@@ -9,44 +9,11 @@ namespace WCS.Model.ApiModel.SingleLight
         /// <summary>
         /// 巷道灯颜色 如果不传 默认为-1  不发送对应指令
         /// </summary>
-        public int WarningLightColor { get; set; } = -1;
-        public int WarningLightMode { get; set; } = -1;
-        /// <summary>
-        /// 巷道灯蜂鸣器模式 如果不传 默认为-1  不发送对应指令
-        /// </summary>
-        public int WarningBuzzerMode { get; set; } = -1;
-
+        public int ColorMode { get; set; } = -1;
+        public int LightMode { get; set; } = -1;
         /// <summary>
         /// 库位灯控制
         /// </summary>
-        public List<StoreListItem> StoreList { get; set; }
+        public List<string> StoreCodes { get; set; }
     }
-
-    public class StoreListItem
-    {
-        #region 
-        /// <summary>
-        /// 库位编码
-        /// </summary>
-        public string StoreCode { get; set; }
-        /// <summary>
-        /// 货架Id
-        /// </summary>
-        public int ShelfId { get; set; } = 0;
-        /// <summary>
-        /// 板子Id
-        /// </summary>
-        public int BoardId { get; set; } = 0;
-        /// <summary>
-        /// 亮灯模式
-        /// </summary>
-        public int LightMode { get; set; } = 0;
-
-        /// <summary>
-        /// 亮灯颜色
-        /// </summary>
-        public int LightColor { get; set; } = 0;
-        #endregion
-    }
-
 }

WCS.Model/ApiModel/SingleLight/TurnoffLightByAreaRequest.cs

@@ -0,0 +1,12 @@
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WCS.Model.ApiModel.SingleLight
+{
+    public class TurnoffLightByAreaRequest : RequestBase
+    {
+        public string Area { get; set; } = string.Empty;
+    }
+}

WCS.Model/WCS.Model.csproj

@@ -3,4 +3,7 @@
 		<TargetFramework>netstandard2.0</TargetFramework>
 		<LangVersion>latest</LangVersion>
 	</PropertyGroup>
+	<ItemGroup>
+	  <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+	</ItemGroup>
 </Project>

WCS.WebApi/Controllers/HomeController.cs

@@ -1,15 +1,17 @@
-using Microsoft.AspNetCore.Mvc;
+using Kdbndp;
+using Microsoft.AspNetCore.Mvc;
 using NPOI.SS.Formula.Functions;
 using SqlSugar;
 using WCS.BLL.DbModels;
+using WCS.BLL.DbModels.Task;
 using WCS.BLL.HardWare;
 using WCS.BLL.Manager;
 using WCS.BLL.Services.IService;
 using WCS.BLL.Services.Service;
 using WCS.DAL.Db;
+using WCS.DAL.DbModels;
 using WCS.Model;
 using WCS.Model.ApiModel.Home;
-using Mode = WCS.BLL.HardWare.Mode;
 
 namespace WCS.WebApi.Controllers
 {
@@ -137,10 +139,11 @@ namespace WCS.WebApi.Controllers
                 var tcpClients = TCPClientManager.TCPClients.Select(t => new
                 {
                     RemoteIPHost = t.RemoteIPHost,
-                    IsOnline = t.IsOnline,
+                    IsReceivedClientOnline = t.IsReceivedClientOnline,
+                    IsSendClientOnline = t.IsSendClientOnline,
                     IsFirstConnected = t.IsFirstConnected,
-                    tcpClientIsNull = t.tcpClient == null,
-                    tcpClientIsOnLine = t.tcpClient?.Online,
+                    tcpClientIsNull = t.tcpSendClient == null,
+                    tcpClientIsOnLine = t.tcpSendClient?.Online,
 
                 }).ToList();
                 //直接返回当前内存中缓存的货架和状态
@@ -211,12 +214,12 @@ namespace WCS.WebApi.Controllers
                 if (request.IsResetAll == false)
                     shelfs = ShelfManager.Shelves
                                              .Where(t => request.SelfIds.Contains(t.ShelfId))
-                                             .Where(t => t.CurrentMode != Mode.待机模式)
+                                             .Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                              .ToList();
                 else
                     shelfs = ShelfManager.Shelves
                                              .Where(t => request.GroupNames.Contains(t.GroupName))
-                                             .Where(t => t.CurrentMode != Mode.待机模式)
+                                             .Where(t => t.CurrentMode != TaskModeEnum.待机模式)
                                              .ToList();
                 foreach (var shelf in shelfs)
                 {
@@ -289,5 +292,550 @@ namespace WCS.WebApi.Controllers
                 };
             }
         }
+
+        /// <summary>
+        /// 生成模组信息
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("generateModuleInfo")]
+        [HttpPost(Name = "generateModuleInfo")]
+        public async Task<ResponseBase> generateModuleInfo(RequestBase request)
+        {
+            try
+            {
+                //获取液晶的货架
+                var shelfInfos = DbHelp.db.Queryable<ShelfInfo>()
+                                          .Where(t => t.ShelfTypeName.Contains("液晶") && !t.ShelfCode.Contains("CP"))
+                                          .ToList();
+                var moduleInfos = new List<ModuleInfo>();
+
+                int boardId = 1;
+                var lastClientCode = string.Empty;
+
+                foreach (var shelfInfo in shelfInfos)
+                {
+                    if (lastClientCode != shelfInfo.ClientIp)
+                    {
+                        lastClientCode = shelfInfo.ClientIp;
+                        boardId = 1;
+                    }
+                    int shelfNumber = 1;
+                    int floorNumber = 1;
+                    int moduleNumber = 0;
+                    while (floorNumber <= 4)
+                    {
+                        moduleNumber++;
+                        if (moduleNumber > 7)
+                        {
+                            shelfNumber++;
+                            moduleNumber = 1;
+                        }
+                        if (shelfNumber > 4)
+                        {
+                            floorNumber++;
+                            shelfNumber = 1;
+                        }
+
+                        if (floorNumber == 5)
+                        {
+                            continue;
+                        }
+
+                        var moduleCode = $"{shelfInfo.ShelfCode}-{shelfNumber}-L{floorNumber}-{moduleNumber}";
+                        var module = new ModuleInfo()
+                        {
+                            ModuleCode = moduleCode,
+                            ShelfTypeId = 3,
+                            ShelfId = shelfInfo.Id,
+                            ShelfCode = shelfInfo.ShelfCode,
+                            BoardId = boardId++,
+                            LightCount = 1,
+                            CleintIp = shelfInfo.ClientIp,
+                            GroupName = shelfInfo.GroupName,
+                            R = floorNumber.ToString(),
+                            C = moduleNumber.ToString(),
+                            IsEnable = true,
+                        };
+                        moduleInfos.Add(module);
+                    }
+                    ;
+                }
+
+                DbHelp.db.Insertable(moduleInfos).ExecuteCommand();
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "生成成功！",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "生成失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        [Route("generateCPModuleInfo")]
+        [HttpPost(Name = "generateCPModuleInfo")]
+        public async Task<ResponseBase> generateCPModuleInfo(RequestBase request)
+        {
+            try
+            {
+                //获取液晶的货架
+                var shelfInfos = DbHelp.db.Queryable<ShelfInfo>()
+                                          .Where(t => t.ShelfTypeName.Contains("液晶") && t.ShelfCode.Contains("CP"))
+                                          .ToList();
+                var moduleInfos = new List<ModuleInfo>();
+
+                int boardId = 1;
+                var lastClientCode = string.Empty;
+
+                foreach (var shelfInfo in shelfInfos)
+                {
+                    if (lastClientCode != shelfInfo.ClientIp)
+                    {
+                        lastClientCode = shelfInfo.ClientIp;
+                        boardId = 1;
+                    }
+
+                    //先拆分shelfCode
+                    var input = shelfInfo.ShelfCode.Split("-")[1];
+                    List<int> numbers = new List<int>();
+                    for (int i = 0; i < input.Length; i += 2)
+                    {
+                        // 提取两位字符
+                        string numberStr = input.Substring(i, 2);
+                        // 转换为整数并添加到列表中
+                        int number = int.Parse(numberStr);
+                        numbers.Add(number);
+                    }
+                    // 将列表转换为数组（如果需要）
+                    int[] shelfNumbers = numbers.ToArray();
+                    foreach (var shelfNumber in shelfNumbers)
+                    {
+                        int floorNumber = 1;
+                        int moduleNumber = 0;
+                        while (floorNumber <= 4)
+                        {
+                            moduleNumber++;
+                            if (moduleNumber > 7)
+                            {
+                                moduleNumber = 1;
+                                floorNumber++;
+                            }
+                            if (floorNumber == 5)
+                            {
+                                continue;
+                            }
+                            var moduleCode = $"CP-{shelfNumber}-L{floorNumber}-{moduleNumber}";
+                            var module = new ModuleInfo()
+                            {
+                                ModuleCode = moduleCode,
+                                ShelfTypeId = 3,
+                                ShelfId = shelfInfo.Id,
+                                ShelfCode = shelfInfo.ShelfCode,
+                                BoardId = boardId++,
+                                LightCount = 1,
+                                CleintIp = shelfInfo.ClientIp,
+                                GroupName = shelfInfo.GroupName,
+                                R = floorNumber.ToString(),
+                                C = moduleNumber.ToString(),
+                                IsEnable = true,
+                            };
+                            moduleInfos.Add(module);
+                        }
+
+                    }
+                }
+
+                DbHelp.db.Insertable(moduleInfos).ExecuteCommand();
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "生成成功！",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "生成失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        /// <summary>
+        /// 进入调试模式
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("goInDebugMode")]
+        [HttpPost(Name = "goInDebugMode")]
+        public async Task<ResponseBase> goInDebugMode(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+                //进入调试模式
+                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                client.Send(data);
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        [Route("goOutDebugMode")]
+        [HttpPost(Name = "goOutDebugMode")]
+        public async Task<ResponseBase> goOutDebugMode(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+                //退出调试模式
+                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                client.Send(data);
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        [Route("setId")]
+        [HttpPost(Name = "setId")]
+        public async Task<ResponseBase> setId(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+                //退出调试模式
+                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xDB, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                client.Send(data);
+
+                var boardId = request.StartId;
+                var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
+                // 检查是否需要交换字节  
+                if (BitConverter.IsLittleEndian)
+                {
+                    // 如果是小端序系统，则交换字节  
+                    byte temp = boardIdData[0];
+                    boardIdData[0] = boardIdData[1];
+                    boardIdData[1] = temp;
+                }
+
+                Thread.Sleep(3000);
+                byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                data1[6] = boardIdData[0];
+                data1[7] = boardIdData[1];
+
+                client.Send(data1);
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        [Route("setLight")]
+        [HttpPost(Name = "setLight")]
+        public async Task<ResponseBase> setLight(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+
+                var boardId = request.StartId;
+                var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
+                // 检查是否需要交换字节  
+                if (BitConverter.IsLittleEndian)
+                {
+                    // 如果是小端序系统，则交换字节  
+                    byte temp = boardIdData[0];
+                    boardIdData[0] = boardIdData[1];
+                    boardIdData[1] = temp;
+                }
+                byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                data1[7] = boardIdData[0];
+                data1[8] = boardIdData[1];
+
+                client.Send(data1);
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+        [Route("testLight")]
+        [HttpPost(Name = "testLight")]
+        public async Task<ResponseBase> testLight(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+
+                var boardId = request.StartId;
+                for (; boardId <= 224; boardId++)
+                {
+                    var boardIdData = BitConverter.GetBytes(unchecked((short)boardId));
+                    // 检查是否需要交换字节  
+                    if (BitConverter.IsLittleEndian)
+                    {
+                        // 如果是小端序系统，则交换字节  
+                        byte temp = boardIdData[0];
+                        boardIdData[0] = boardIdData[1];
+                        boardIdData[1] = temp;
+                    }
+
+                    //发送入库亮灯
+                    byte[] data1 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xA1, 0x01, 0x02, 0x02, 0x0A, 0x00, 0x00, 0x00 };
+                    data1[7] = boardIdData[0];
+                    data1[8] = boardIdData[1];
+
+                    client.Send(data1);
+                    Thread.Sleep(490);
+                    //发送退出入库
+                    byte[] data2 = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xA1, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+                    data2[7] = boardIdData[0];
+                    data2[8] = boardIdData[1];
+                    client.Send(data2);
+                    Thread.Sleep(10);
+                }
+
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        [Route("resetByTCP")]
+        [HttpPost(Name = "resetByTCP")]
+        public async Task<ResponseBase> resetByTCP(SetBoardIdRequest request)
+        {
+            try
+            {
+                //获取TCP
+                var client = TCPClientManager.TCPClients
+                                             .Where(t => t.RemoteIPHost == request.IPPort)
+                                             .First();
+                if (client == null)
+                {
+                    return new ResponseBase<object>()
+                    {
+                        Code = 300,
+                        Message = "未获取到对应连接，请检查地址",
+                        Data = null
+                    };
+                }
+                byte[] data = { 0x08, 0x00, 0x00, 0x07, 0xFF, 0xBE, 0x52, 0x54, 0x41, 0x52, 0x54, 0x0A, 0xED };
+                client.Send(data);
+
+                return new ResponseBase<object>()
+                {
+                    Code = 200,
+                    Message = "指令发送成功",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase<object>()
+                {
+                    Code = 300,
+                    Message = "指令发送失败" + ex.Message,
+                    Data = null
+                };
+            }
+        }
+
+
+        /// <summary>
+        /// 配置库位编码
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("setStoreCode")]
+        [HttpPost(Name = "setStoreCode")]
+        public async Task<ResponseBase> setStoreCode(SetBoardIdRequest request)
+        {
+            try
+            {
+                var errorList = new List<string>();
+                //1.获取所有液晶标签货架
+                var shelfs = ShelfManager.Shelves.Where(t => t.ShelfTypeName == "液晶标签货架")
+                                                 .WhereIF(!string.IsNullOrEmpty(request.IPPort), t => t.ClientIp == request.IPPort)
+                                                 .Select(t => t as MXL4Shelf)
+                                                 .ToList();
+                shelfs.ForEach(t =>
+                {
+                    t.MXL4Modules.ForEach(m =>
+                    {
+                        try
+                        {
+                            m.SendStoreCode(m.ModuleCode, t.TcpCleint);
+                        }
+                        catch (Exception ex)
+                        {
+                            errorList.Add($"模组{m.ModuleCode}更新库位ID失败！原因：{ex.Message}");
+                        }
+
+                    });
+                });
+                return new ResponseCommon
+                {
+                    Code = 200,
+                    Message = "success",
+                    Data = errorList
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
     }
 }

WCS.WebApi/Controllers/MXL4Controller.cs

@@ -45,5 +45,116 @@ namespace WCS.WebApi.Controllers
             }
         }
 
+        [Route("cancelOrderMXL4")]
+        [HttpPost(Name = "cancelOrderMXL4")]
+        public async Task<ResponseBase> cancelOrderMXL4(CancelRequest request)
+        {
+            try
+            {
+                return await _mxl4Service.cancelOrderMXL4(request);
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        /// <summary>
+        /// 通过工单号（必填）+物料编码(非必填) 进行取消订单
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("cancelOrderByCode")]
+        [HttpPost(Name = "cancelOrderByCode")]
+        public async Task<ResponseBase> cancelOrderByCode(CancelOrderByCodeRequest request)
+        {
+            try
+            {
+                return await _mxl4Service.cancelOrderByCode(request);
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        /// <summary>
+        /// 刷新库存信息 当上游系统入库后可以调用此接口对硬件显示的库存信息进行刷新
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [Route("refreshInventory")]
+        [HttpPost(Name = "refreshInventory")]
+        public async Task<ResponseCommon> refreshInventory(RefreshInventoryRequest request)
+        {
+            try
+            {
+                //校验传入的参数
+                if (request.StoreCodes == null || request.StoreCodes.Count == 0)
+                { 
+                    return new ResponseCommon()
+                    {
+                        Code = 201,
+                        Message = "操作失败：缺少需要刷新的库位！",
+                    };
+                }
+                return await _mxl4Service.refreshInventoryRequest(request);
+            }
+            catch (Exception ex)
+            {
+                return new ResponseCommon()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+
+        #region 调试用的API
+        [Route("reSetAll")]
+        [HttpPost(Name = "reSetAll")]
+        public async Task<ResponseBase> reSetAll()
+        {
+            try
+            {
+                return await _mxl4Service.reSetAll();
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        [Route("defaultDisplay")]
+        [HttpPost(Name = "defaultDisplay")]
+        public async Task<ResponseBase> defaultDisplay()
+        {
+            try
+            {
+                return await _mxl4Service.defaultDisplay();
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+        #endregion
     }
 }

WCS.WebApi/Controllers/RequestResponseLoggingMiddleware.cs

@@ -74,7 +74,7 @@ namespace WCS.WebApi.Controllers
             {
                 var guid = Guid.NewGuid();
                 //TO DO如何将记日志的 和不记日志的分开 解耦
-                if (!context.Request.Path.ToString().Contains("getInterfaceRecord") && !context.Request.Path.ToString().Contains("getShelfStatus"))
+                if (!context.Request.Path.ToString().Contains("getInterfaceRecord") && !context.Request.Path.ToString().Contains("getShelfStatus") && !context.Request.Path.ToString().Contains("GetKanBanData"))
                 {
                     try
                     {

WCS.WebApi/Controllers/SingleLightController.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Mvc;
 using WCS.BLL.Services.IService;
 using WCS.BLL.Services.Service;
+using WCS.DAL.Db;
+using WCS.DAL.DbModels;
 using WCS.Model;
 using WCS.Model.ApiModel;
 using WCS.Model.ApiModel.SelfCheck;
@@ -44,5 +46,210 @@ namespace WCS.WebApi.Controllers
             }
         }
 
+        [Route("turnoffLightByArea")]
+        [HttpPost(Name = "turnoffLightByArea")]
+        public async Task<ResponseBase> TurnoffLightByArea(TurnoffLightByAreaRequest request)
+        {
+            try
+            {
+                return await _singleLightService.TurnoffLightByArea(request);
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+        [Route("GetKanBanData")]
+        [HttpGet(Name = "GetKanBanData")]
+        public async Task<ResponseBase> GetKanBanData()
+        {
+            try
+            {
+                //获取单灯类型的库位
+                var stores = DbHelp.db.Queryable<StoreInfo>()
+                                      .Where(t => t.ShelfTypeId == 2)
+                                      .OrderBy(t => t.Area)
+                                      .OrderBy(t => t.StoreCode)
+                                      .Select(t => new
+                                      {
+                                          Area = t.Area,
+                                          StoreCode = t.StoreCode,
+                                          LightMode = t.LightMode,
+                                          ColorMode = t.ColorMode,
+                                      })
+                                      .ToList();
+                return new ResponseCommon()
+                {
+                    Code = 200,
+                    Message = "success",
+                    Data = stores
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
+
+        [Route("GenerateSingleLightStoreInfo")]
+        [HttpGet(Name = "GenerateSingleLightStoreInfo")]
+        public async Task<ResponseBase> GenerateSingleLightStoreInfo()
+        {
+            try
+            {
+                //获取单灯类型的货架
+                var shelfInfo = DbHelp.db.Queryable<ShelfInfo>()
+                                         .Where(t => t.ShelfTypeName == "信息化货架")
+                                         .OrderBy(t => t.ShelfCode)
+                                         .ToList();
+                var storesToSave = new List<StoreInfo>();
+                var modulesToSave = new List<ModuleInfo>();
+
+                foreach (var shelf in shelfInfo)
+                {
+                    if (shelf.ShelfCode == "C07-4")
+                        ;
+                    var row = shelf.Rowcounts % 2;
+                    //如果是奇数行 
+                    if (row == 1)
+                    {
+                        //之前已经占用的id
+                        var id = (shelf.Rowcounts - 1) * (shelf.Columncounts + 6);
+
+                        //奇数行 灯Id是最后一个灯
+                        for (int i = shelf.Columncounts; i > 0; i--)
+                        {
+
+
+                            var storeInfo = new StoreInfo()
+                            {
+                                StoreCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfTypeId = shelf.ShelfTypeId,
+                                ModuleId = 0,
+                                ModuleCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfId = shelf.Id,
+                                ShelfCode = shelf.ShelfCode,
+                                BoardId = ++id,
+                                LightNumber = 1,
+                                Priority = 0,
+                                R = shelf.Rowcounts.ToString(),
+                                C = i.ToString(),
+                                Wei = "1",
+                                SingleLightNumber = 1,
+                                LightMode = 0,
+                                ColorMode = 0,
+                                GroupName = shelf.GroupName,
+                                Area = shelf.ShelfCode.Substring(0, 1),
+                            };
+                            storesToSave.Add(storeInfo);
+
+                            var moduleInfo = new ModuleInfo()
+                            {
+                                ModuleCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfTypeId = shelf.ShelfTypeId,
+                                ShelfId = shelf.Id,
+                                ShelfCode = shelf.ShelfCode,
+                                BoardId = storeInfo.BoardId,
+                                LightCount = 1,
+                                CleintIp = shelf.ClientIp,
+                                GroupName = shelf.GroupName,
+                                R = storeInfo.R,
+                                C = storeInfo.C,
+                                Bigshelfcode = "",
+                                IsEnable = true,
+                                CurrentMode = BLL.DbModels.Task.TaskModeEnum.待机模式,
+                            };
+                            modulesToSave.Add(moduleInfo);
+                        }
+
+                        shelf.LightId = ++id;
+                    }
+                    //偶数行
+                    else
+                    {
+                        //之前已经占用的id
+                        var id = (shelf.Rowcounts - 1) * (shelf.Columncounts + 6);
+                        shelf.LightId = ++id;
+
+                        //灯占6个ID
+                        id = id + 5;
+                        //奇数行 灯Id是最后一个灯
+                        for (int i = 1; i <= shelf.Columncounts; i++)
+                        {
+                            var storeInfo = new StoreInfo()
+                            {
+                                StoreCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfTypeId = shelf.ShelfTypeId,
+                                ModuleId = 0,
+                                ModuleCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfId = shelf.Id,
+                                ShelfCode = shelf.ShelfCode,
+                                BoardId = ++id,
+                                LightNumber = 1,
+                                Priority = 0,
+                                R = shelf.Rowcounts.ToString(),
+                                C = i.ToString(),
+                                Wei = "1",
+                                SingleLightNumber = 1,
+                                LightMode = 0,
+                                ColorMode = 0,
+                                GroupName = shelf.GroupName,
+                                Area = shelf.ShelfCode.Substring(0, 1),
+                            };
+                            storesToSave.Add(storeInfo);
+
+                            var moduleInfo = new ModuleInfo()
+                            {
+                                ModuleCode = shelf.ShelfCode + "-" + i.ToString(),
+                                ShelfTypeId = shelf.ShelfTypeId,
+                                ShelfId = shelf.Id,
+                                ShelfCode = shelf.ShelfCode,
+                                BoardId = storeInfo.BoardId,
+                                LightCount = 1,
+                                CleintIp = shelf.ClientIp,
+                                GroupName = shelf.GroupName,
+                                R = storeInfo.R,
+                                C = storeInfo.C,
+                                Bigshelfcode = "",
+                                IsEnable = true,
+                                CurrentMode = BLL.DbModels.Task.TaskModeEnum.待机模式,
+                            };
+                            modulesToSave.Add(moduleInfo);
+                        }
+                    }
+
+                }
+
+                DbHelp.db.Insertable(storesToSave).ExecuteCommand();
+                DbHelp.db.Insertable(modulesToSave).ExecuteCommand();
+                DbHelp.db.Updateable(shelfInfo).ExecuteCommand();
+
+                return new ResponseCommon()
+                {
+                    Code = 200,
+                    Message = "success",
+                    Data = null
+                };
+            }
+            catch (Exception ex)
+            {
+                return new ResponseBase()
+                {
+                    Code = 300,
+                    Message = "操作失败：" + ex.Message,
+                };
+            }
+        }
+
     }
 }

WCS.WebApi/Program.cs

@@ -21,6 +21,8 @@ namespace WebApi
         {
             try
             {
+                Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+
                 //<2F><>ʼ<EFBFBD><CABC>websocket
                 WebSoceketManager.InitWebSocket();
 
@@ -37,7 +39,8 @@ namespace WebApi
                 ShelfManager.InitShelves();
 
                 //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD>ط<EFBFBD><D8B7>߳<EFBFBD>
-                WarningManager.StartWarningMessageThread();
+                //WarningManager.StartWarningMessageThread();
+                MKYBackgroundThread.InitBackgroundThread();
 
                 //<2F><>Ѷ<EFBFBD><D1B6>˾<EFBFBD><CBBE>̨<EFBFBD>߳<EFBFBD>
                 if (LocalFile.Config.IsMx)
@@ -73,7 +76,6 @@ namespace WebApi
                 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
                 builder.Services.AddEndpointsApiExplorer();
                 builder.Services.AddSwaggerGen();
-
                 builder.Services.AddScoped<IInstoreService, InstoreService>();
                 builder.Services.AddScoped<IOutstoreService, OutstoreService>();
                 builder.Services.AddScoped<IHomerService, HomerService>();

WCS.WebApi/Properties/PublishProfiles/FolderProfile.pubxml

@@ -4,7 +4,7 @@ https://go.microsoft.com/fwlink/?LinkID=208121.
 -->
 <Project>
   <PropertyGroup>
-    <DeleteExistingFiles>false</DeleteExistingFiles>
+    <DeleteExistingFiles>true</DeleteExistingFiles>
     <ExcludeApp_Data>false</ExcludeApp_Data>
     <LaunchSiteAfterPublish>true</LaunchSiteAfterPublish>
     <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
@@ -15,8 +15,9 @@ https://go.microsoft.com/fwlink/?LinkID=208121.
     <_TargetId>Folder</_TargetId>
     <SiteUrlToLaunchAfterPublish />
     <TargetFramework>net6.0</TargetFramework>
-    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
     <ProjectGuid>118d453b-1693-4c00-8378-20ecbfcf2700</ProjectGuid>
     <SelfContained>false</SelfContained>
+    <PublishSingleFile>false</PublishSingleFile>
   </PropertyGroup>
 </Project>

WCS.WebApi/WCS后端.sln

@@ -16,6 +16,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "货架标准上位机", "..
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WCS.Model", "..\WCS.Model\WCS.Model.csproj", "{7CE9AF07-3538-46C3-BBF0-A039BDE15AAF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Encode", "..\Encode\Encode.csproj", "{F344121D-856D-4E5C-8519-6EADDE98616E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -42,6 +44,10 @@ Global
 		{7CE9AF07-3538-46C3-BBF0-A039BDE15AAF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7CE9AF07-3538-46C3-BBF0-A039BDE15AAF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7CE9AF07-3538-46C3-BBF0-A039BDE15AAF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F344121D-856D-4E5C-8519-6EADDE98616E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F344121D-856D-4E5C-8519-6EADDE98616E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F344121D-856D-4E5C-8519-6EADDE98616E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F344121D-856D-4E5C-8519-6EADDE98616E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

货架标准上位机/App.xaml

@@ -21,8 +21,8 @@
             <!--字体-->
             <FontFamily x:Key="IconFont">pack://application,,,/智能仓储WCS管理系统;component/Fonts/#iconfont</FontFamily>
             <!--字符串-->
-            <!--<sys:String x:Key="AboutInfo1">卓越盟讯</sys:String>-->
-            <sys:String x:Key="AboutInfo1">金川数智</sys:String>
+            <sys:String x:Key="AboutInfo1">卓越盟讯</sys:String>
+            <!--<sys:String x:Key="AboutInfo1">金川数智</sys:String>-->
             <sys:String x:Key="AboutInfo2">智造未来</sys:String>
         </ResourceDictionary>
     </Application.Resources>

货架标准上位机/ScannerManager.cs

@@ -4,7 +4,9 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using System.IO.Ports;
+using TouchSocket.Core;
+using TouchSocket.SerialPorts;
+using TouchSocket.Sockets;
 using 智能仓储WCS管理系统.Views.Controls;
 
 namespace 智能仓储WCS管理系统
@@ -22,29 +24,33 @@ namespace 智能仓储WCS管理系统
             {
                 try
                 {
-                    var _serialPort = new SerialPort();
-
-                    // 初始化串口配置
-                    _serialPort = new SerialPort
+                    var client = new SerialPortClient();
+                    //成功连接到端口
+                    client.Connected = (client, e) =>
                     {
-                        PortName = COM,          
-                        BaudRate = 9600,
-                        Parity = Parity.None,
-                        DataBits = 8,
-                        StopBits = StopBits.One,
-                        Handshake = Handshake.None,
-                        Encoding = Encoding.UTF8   // 根据设备要求选择编码
+                        Logs.Write($"扫码枪{client.MainSerialPort.PortName},已成功连接！", LogsType.Scanner);
+                        //初始化扫码枪对象
+                        var Scanner = new Scanner()
+                        {
+                            SerialPortClient = (SerialPortClient)client,
+                            //ScannerDisplayControl = new ScannerDisplayControl(client.MainSerialPort.PortName),
+                            COM = client.MainSerialPort.PortName,
+                            TempCode = string.Empty,
+                        };
+                        Scanners.Add(Scanner);
+                        return EasyTask.CompletedTask;
                     };
-                    _serialPort.Open();
+                    client.Setup(new TouchSocket.Core.TouchSocketConfig()
+                        .SetSerialPortOption(new SerialPortOption()
+                        {
+                            BaudRate = 9600,//波特率
+                            DataBits = 8,//数据位
+                            Parity = System.IO.Ports.Parity.None,//校验位
+                            PortName = COM,
+                            StopBits = System.IO.Ports.StopBits.One//停止位
+                        }));
 
-                    var Scanner = new Scanner()
-                    {
-                        SerialPort = _serialPort,
-                        //ScannerDisplayControl = new ScannerDisplayControl(client.MainSerialPort.PortName),
-                        COM = COM,
-                        TempCode = string.Empty,
-                    };
-                    Scanners.Add(Scanner);
+                    client.Connect(LocalFile.Config.ScannerTimeOut, new CancellationToken());
                 }
                 catch (Exception ex)
                 {
@@ -57,7 +63,7 @@ namespace 智能仓储WCS管理系统
 
     public class Scanner
     {
-        public SerialPort SerialPort { get; set; }
+        public SerialPortClient SerialPortClient { get; set; }
 
         public ScannerDisplayControl ScannerDisplayControl { get; set; }
 

货架标准上位机/ViewModels/InInventoryViewModel.cs

@@ -30,7 +30,6 @@ using WCS.Model.ApiModel.MatBaseInfo;
 using System.Security.Cryptography;
 using Ping9719.WpfEx;
 using System.Diagnostics.Eventing.Reader;
-using System.IO.Ports;
 
 namespace 智能仓储WCS管理系统.ViewModel
 {
@@ -42,44 +41,30 @@ namespace 智能仓储WCS管理系统.ViewModel
             var scanners = ScannerManager.Scanners;
             foreach (var scanner in scanners)
             {
-                scanner.SerialPort.DataReceived += SerialPort_DataReceived;
+                scanner.SerialPortClient.Received = (client, e) =>
+                {
+                    //获取串口号
+                    var COM = client.MainSerialPort.PortName;
+                    //获取扫码枪对象
+                    var scanner = ScannerManager.Scanners.Where(t => t.COM == COM).FirstOrDefault();
+                    if (scanner == null)
+                        return EasyTask.CompletedTask;
+                    int newBytes = e.ByteBlock.Len;
+                    if (newBytes > 0)
+                    {
+                        var currentScanedCode = Encoding.UTF8.GetString(e.ByteBlock, 0, e.ByteBlock.Len);
+                        Logs.Write($"接收到扫码枪[{scanner.COM}]扫码数据{currentScanedCode}", LogsType.Scanner);
+                        scanner.TempCode += currentScanedCode;
+                        //校验末尾码
+                        CheckDataCompleteness(scanner);
+                        scanner.ScannerDisplayControl.RefreshValues(scanner.ShelfCode, scanner.MatSn, scanner.InstoreUser);
+                    }
+                    return EasyTask.CompletedTask;
+                };
             }
             RevertScannerStatus();
         }
 
-
-        public void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
-        {
-            try
-            {
-                var _serialPort = sender as SerialPort;
-                if (_serialPort == null)
-                    return;
-                //// 读取所有可用数据
-                string receivedData = _serialPort.ReadExisting();
-                //获取串口号
-                var COM = _serialPort.PortName;
-                //获取扫码枪对象
-                var scanner = ScannerManager.Scanners.Where(t => t.COM == COM).FirstOrDefault();
-                if (scanner == null)
-                    return;
-                //int newBytes = e.ByteBlock.Len;
-                if (receivedData.Length > 0)
-                {
-                    var currentScanedCode = receivedData;
-                    Logs.Write($"接收到扫码枪[{scanner.COM}]扫码数据{currentScanedCode}", LogsType.Scanner);
-                    scanner.TempCode += currentScanedCode;
-                    //校验末尾码
-                    CheckDataCompleteness(scanner);
-                    scanner.ScannerDisplayControl.RefreshValues(scanner.ShelfCode, scanner.MatSn, scanner.InstoreUser);
-                }
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"接收数据错误: {ex.Message}");
-            }
-        }
-
         #region Property
         private string shelfCode;
         public string ShelfCode

货架标准上位机/货架标准上位机.csproj

@@ -60,8 +60,8 @@
 		<PackageReference Include="SqlSugar" Version="5.1.4.149" />
 		<PackageReference Include="SqlSugar.MySqlConnector" Version="5.1.3.42" />
 		<PackageReference Include="System.Data.SQLite.Core" Version="1.0.118" />
-		<PackageReference Include="System.IO.Ports" Version="9.0.0" />
 		<PackageReference Include="TouchSocket.Http" Version="2.0.3" />
+		<PackageReference Include="TouchSocket.SerialPorts" Version="2.0.2" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -84,12 +84,12 @@
 		<Resource Include="Resources\Logo.ico" />
 		<Resource Include="Resources\Logo.png" />
 		<Resource Include="Resources\主页.png" />
-		<Resource Include="Resources\入库.png" />
-		<Resource Include="Resources\出库.png" />
-		<Resource Include="Resources\盘点.png" />
-		<Resource Include="Resources\查询.png" />
-		<Resource Include="Resources\货架.png" />
-		<Resource Include="Resources\物料.png" />
+		<Resource Include="Resources\入库.png"/>
+		<Resource Include="Resources\出库.png"/>
+		<Resource Include="Resources\盘点.png"/>
+		<Resource Include="Resources\查询.png"/>
+		<Resource Include="Resources\货架.png"/>
+		<Resource Include="Resources\物料.png"/>
 		<Resource Include="Resources\权限.png" />
 		<Resource Include="Resources\调试.png" />
 	</ItemGroup>