2

schangxiang@126.com

2024-10-02 5d523171b8bc7db46ca76b11640dbfcb0120ce84

2

 SDA/iWareModel/EnumType/EDevice/Rgv/EStationMode.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareModel
{
    public enum EStationMode
    {
        å…³æœºæ¨¡å¼ = 0,
        æ‰‹åŠ¨æ¨¡å¼ = 1,
        è‡ªåŠ¨å¾…机模式 = 2,
        è‡ªåŠ¨è¿è¡Œæ¨¡å¼ = 3,
    }
}

 SDA/iWareModel/EnumType/EDevice/Rgv/EStationState.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareModel
{
    public enum EStationState
    {
        //空闲 = 0,
        //任务中 = 1,
        //[EditBy shaocx,2022-05-11]
        ä»»åŠ¡ä¸­ = 0,
        ç©ºé—² = 1
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/DB/RgvComm.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,385 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareSda.Devices._3_Station.StationModel
{

    #region å†™

    public class StationDB2ObjForWriteComm
    {
        /// <summary>
        /// ç«™ç‚¹ç¼–号
        /// </summary>
        [Description("站点编号")]
        public string StationCode { get; set; }

        /// <summary>
        /// è¯»ç æ•°æ®è§£æžå®Œæˆ
        /// </summary>
        [Description("读码数据解析完成")]
        public bool W_DataFinish { get; set; }

        /// <summary>
        /// é½å¥—信息（998齐套，999异常出库）
        /// </summary>
        [Description("齐套信息（998齐套，999异常出库）")]
        public string W_KittingInfo { get; set; }

        /// <summary>
        /// åˆ†é…æ”¾æ–™åº“位号
        /// </summary>
        [Description("分配放料库位号")]
        public string W_Destination_In { get; set; }

        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [Description("任务号")]
        public string W_TaskID { get; set; }


        /// <summary>
        /// æ¥æ–™é•¿åº¦
        /// </summary>
        [Description("来料长度")]
        public string W_Length { get; set; }

        /// <summary>
        /// æ¥æ–™å®½åº¦
        /// </summary>
        [Description("来料宽度")]
        public string W_Width { get; set; }


        /// <summary>
        /// æ¥æ–™é«˜åº¦
        /// </summary>
        [Description("来料高度")]
        public string W_Height { get; set; }

        /// <summary>
        /// è¯·æ±‚出库
        /// </summary>
        [Description("请求出库")]
        public bool W_ReqOut { get; set; }

        /// <summary>
        /// åˆ†é…å‡ºåº“库位号
        /// </summary>
        [Description("分配出库库位号")]
        public string W_Destination_Out { get; set; }

        /// <summary>
        /// æ˜¯å¦æ—‹è½¬
        /// </summary>
        [Description("是否旋转")]
        public bool W_IsRotate { get; set; }



        /// <summary>
        /// åŒ…件长
        /// </summary>
        [Description("包件长")]
        public string W_PackageLength { get; set; }

        /// <summary>
        /// åŒ…件宽
        /// </summary>
        [Description("包件宽")]
        public string W_PackageWidth { get; set; }


        /// <summary>
        /// çº¸ç®±é«˜
        /// </summary>
        [Description("纸箱高")]
        public string W_CartonHeight { get; set; }

        /// <summary>
        /// çº¸ç®±å®½
        /// </summary>
        [Description("纸箱宽")]
        public string W_CartonWidth { get; set; }

        /// <summary>
        /// æ”¾æ–™X偏移
        /// </summary>
        [Description("放料X偏移")]
        public string W_X_Offset { get; set; }

        /// <summary>
        /// æ”¾æ–™Y偏移
        /// </summary>
        [Description("放料Y偏移")]
        public string W_Y_Offset { get; set; }
    }

    /// <summary>
    /// æ¯ä¸ªç«™ç‚¹çš„写数据
    /// </summary>
    public class StationDBForWriteComm
    {
        /// <summary>
        /// ç«™ç‚¹ç¼–号
        /// </summary>
        [Description("站点编号")]
        public string StationCode { get; set; }

        /// <summary>
        /// è¯»ç æ•°æ®è§£æžå®Œæˆ
        /// </summary>
        [Description("读码数据解析完成")]
        public string W_DataFinish { get; set; }

        /// <summary>
        /// é½å¥—信息（998齐套，999异常出库）
        /// </summary>
        [Description("齐套信息（998齐套，999异常出库）")]
        public string W_KittingInfo { get; set; }

        /// <summary>
        /// åˆ†é…æ”¾æ–™åº“位号
        /// </summary>
        [Description("分配放料库位号")]
        public string W_Destination_In { get; set; }

        /// <summary>
        /// ä»»åŠ¡å·
        /// </summary>
        [Description("任务号")]
        public string W_TaskID { get; set; }


        /// <summary>
        /// æ¥æ–™é•¿åº¦
        /// </summary>
        [Description("来料长度")]
        public string W_Length { get; set; }

        /// <summary>
        /// æ¥æ–™å®½åº¦
        /// </summary>
        [Description("来料宽度")]
        public string W_Width { get; set; }


        /// <summary>
        /// æ¥æ–™é«˜åº¦
        /// </summary>
        [Description("来料高度")]
        public string W_Height { get; set; }

        /// <summary>
        /// è¯·æ±‚出库
        /// </summary>
        [Description("请求出库")]
        public string W_ReqOut { get; set; }

        /// <summary>
        /// åˆ†é…å‡ºåº“库位号
        /// </summary>
        [Description("分配出库库位号")]
        public string W_Destination_Out { get; set; }

        /// <summary>
        /// æ˜¯å¦æ—‹è½¬
        /// </summary>
        [Description("是否旋转")]
        public string W_IsRotate { get; set; }



        /// <summary>
        /// åŒ…件长
        /// </summary>
        [Description("包件长")]
        public string W_PackageLength { get; set; }

        /// <summary>
        /// åŒ…件宽
        /// </summary>
        [Description("包件宽")]
        public string W_PackageWidth { get; set; }


        /// <summary>
        /// çº¸ç®±é«˜
        /// </summary>
        [Description("纸箱高")]
        public string W_CartonHeight { get; set; }

        /// <summary>
        /// çº¸ç®±å®½
        /// </summary>
        [Description("纸箱宽")]
        public string W_CartonWidth { get; set; }

        /// <summary>
        /// æ”¾æ–™X偏移
        /// </summary>
        [Description("放料X偏移")]
        public string W_X_Offset { get; set; }

        /// <summary>
        /// æ”¾æ–™Y偏移
        /// </summary>
        [Description("放料Y偏移")]
        public string W_Y_Offset { get; set; }

    }

    #endregion

    /// <summary>
    /// æ¯ä¸ªç«™ç‚¹çš„读数据
    /// </summary>
    public class StationDB2ObjForReadComm
    {
        /// <summary>
        /// ç«™ç‚¹ç¼–号
        /// </summary>
        [Description("站点编号")]
        public string StationCode { get; set; }

        /// <summary>
        /// è¯·æ±‚解析读码数据
        /// </summary>
        [Description("请求解析读码数据")]
        public bool R_ReqParseData { get; set; }

        /// <summary>
        /// è¯»ç å™¨è¯»ç ç»“æžœ
        /// </summary>
        [Description("读码器读码结果")]
        public String R_ReadCodeResult { get; set; }

        /// <summary>
        /// æ”¶åˆ°ä»»åŠ¡ä¸‹å‘反馈
        /// </summary>
        [Description("收到任务下发反馈")]
        public bool R_ACK { get; set; }

        /// <summary>
        /// æ¨¡å¼
        /// </summary>
        [Description("模式")]
        public short R_Model { get; set; }

        /// <summary>
        /// è¿è¡ŒçŠ¶æ€
        /// </summary>
        [Description("运行状态")]
        public short R_State { get; set; }

        /// <summary>
        /// æŠ¥è­¦ä»£ç 
        /// </summary>
        [Description("报警代码")]
        public short R_AlarmCode { get; set; }

        /// <summary>
        /// æŠ¥è­¦ä»£ç å†…容，非DB块内容
        /// </summary>
        [Description("报警代码内容，非DB块内容")]
        public string R_AlarmCodeMsg { get; set; }

        /// <summary>
        /// å½“前目标地址
        /// </summary>
        [Description("当前目标地址")]
        public short R_Destination { get; set; }

        /// <summary>
        /// è´§å½¢
        /// </summary>
        [Description("货形")]
        public short R_Shape { get; set; }

        /// <summary>
        /// å½“前任务号
        /// </summary>
        [Description("当前任务号")]
        public int R_TaskID { get; set; }
    }

    public class StationDBForReadComm
    {
        /// <summary>
        /// ç«™ç‚¹ç¼–号
        /// </summary>
        [Description("站点编号")]
        public string StationCode { get; set; }

        /// <summary>
        /// è¯·æ±‚解析读码数据
        /// </summary>
        [Description("请求解析读码数据")]
        public string R_ReqParseData { get; set; }

        /// <summary>
        /// è¯»ç å™¨è¯»ç ç»“æžœ
        /// </summary>
        [Description("读码器读码结果")]
        public String R_ReadCodeResult { get; set; }

        /// <summary>
        /// å…‰ç”µ1状态
        /// </summary>
        [Description("光电1状态")]
        public string R_PH_1 { get; set; }

        /// <summary>
        /// å…‰ç”µ2状态
        /// </summary>
        [Description("光电2状态")]
        public string R_PH_2 { get; set; }

        /// <summary>
        /// æ”¶åˆ°ä»»åŠ¡ä¸‹å‘反馈
        /// </summary>
        [Description("收到任务下发反馈")]
        public string R_ACK { get; set; }

        /// <summary>
        /// æ¨¡å¼
        /// </summary>
        [Description("模式")]
        public string R_Model { get; set; }

        /// <summary>
        /// è¿è¡ŒçŠ¶æ€
        /// </summary>
        [Description("运行状态")]
        public string R_State { get; set; }

        /// <summary>
        /// æŠ¥è­¦ä»£ç 
        /// </summary>
        [Description("报警代码")]
        public string R_AlarmCode { get; set; }

        /// <summary>
        /// å½“前目标地址
        /// </summary>
        [Description("当前目标地址")]
        public string R_Destination { get; set; }

        /// <summary>
        /// å¤–形检测
        /// </summary>
        [Description("外形检测")]
        public string R_Shape { get; set; }

        /// <summary>
        /// å½“前任务号
        /// </summary>
        [Description("当前任务号")]
        public string R_TaskID { get; set; }
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/DB/RgvDB2Obj.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,213 @@

using iWareSda.Devices._3_Station.StationModel;
using System.Collections.Generic;
using System.ComponentModel;
namespace iWareSda
{
    /// <summary>
    /// Station展示实体类
    /// </summary>
    public class StationDB2Obj
    {

        #region å†™å…¥çš„Station信息
        /// <summary>
        /// å¿ƒè·³
        /// </summary>
        [Description("心跳")]
        public bool W_HandShake { get; set; }

        /// <summary>
        /// 1015重新扫码，写为true表示重新扫码，写为false，表示关闭重新扫码。当wcs读到值后，就写为false
        /// </summary>
        [Description("1015重新扫码")]
        public bool W_1015_ReScan { get; set; }

        /// <summary>
        /// 1019重新扫码，写为true表示重新扫码，写为false，表示关闭重新扫码。当wcs读到值后，就写为false
        /// </summary>
        [Description("1019重新扫码")]
        public bool W_1019_ReScan { get; set; }

        /// <summary>
        /// Station_完成ACK
        /// </summary>
        [Description("Station_完成ACK")]
        public bool W_Station_FinishACK { get; set; }

        /// <summary>
        /// 1002扫描失败信号
        /// </summary>
        [Description("1002扫描失败信号")]
        public bool W_1002_ScanFailACK { get; set; }

        /// <summary>
        /// 1004扫描失败信号
        /// </summary>
        [Description("1004扫描失败信号")]
        public bool W_1004_ScanFailACK { get; set; }

        /// <summary>
        /// 1006扫描失败信号
        /// </summary>
        [Description("1006扫描失败信号")]
        public bool W_1006_ScanFailACK { get; set; }

        /// <summary>
        /// 1007扫描失败信号
        /// </summary>
        [Description("1007扫描失败信号")]
        public bool W_1007_ScanFailACK { get; set; }

        /// <summary>
        /// 1002扫描成功信号
        /// </summary>
        [Description("1002扫描成功信号")]
        public bool W_1002_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1004扫描成功信号
        /// </summary>
        [Description("1004扫描成功信号")]
        public bool W_1004_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1006扫描成功信号
        /// </summary>
        [Description("1006扫描成功信号")]
        public bool W_1006_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1007扫描成功信号
        /// </summary>
        [Description("1007扫描成功信号")]
        public bool W_1007_ScanSuccessACK { get; set; }

        /// <summary>
        /// å‡ºåº“发动机的型号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的型号")]
        public string W_Out_MaterialModel { get; set; }

        /// <summary>
        /// å‡ºåº“发动机的订货号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的订货号")]
        public string W_Out_OrderNo { get; set; }

        /// <summary>
        /// å‡ºåº“发动机的编号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的编号")]
        public string W_Out_SerialNumber { get; set; }


        #region å†™çš„站点

        public List<StationDB2ObjForWriteComm> W_StationForWriteCommList { get; set; }

        #endregion


       
        #endregion

        #region è¯»å–到的Station信息
        /// <summary>
        /// å¿ƒè·³
        /// </summary>
        [Description("心跳")]
        public int R_HandShake { get; set; }
        /// <summary>
        /// Station编号
        /// </summary>
        [Description("Station编号")]
        public string R_StationNo { get; set; }


        /// <summary>
        /// 1015扫码
        /// </summary>
        [Description("1015扫码")]
        public string R_1015_Scan { get; set; }

        /// <summary>
        /// 1019扫码
        /// </summary>
        [Description("1019扫码")]
        public string R_1019_Scan { get; set; }

        /// <summary>
        /// 1019发动机的扫码
        /// </summary>
        [Description("1019发动机的扫码")]
        public string R_1019_CargoNoScan { get; set; }

        /// <summary>
        /// 1002扫码
        /// </summary>
        [Description("1002扫码")]
        public string R_1002_Scan { get; set; }

        /// <summary>
        /// 1004扫码
        /// </summary>
        [Description("1004扫码")]
        public string R_1004_Scan { get; set; }

        /// <summary>
        /// 1006扫码
        /// </summary>
        [Description("1006扫码")]
        public string R_1006_Scan { get; set; }


        /// <summary>
        /// 1007扫码
        /// </summary>
        [Description("1007扫码")]
        public string R_1007_Scan { get; set; }

        /// <summary>
        /// 1009的1层检测光电
        /// </summary>
        [Description("1009的1层检测光电")]
        public bool R_1009_High1 { get; set; }

        /// <summary>
        /// 1009的2层检测光电
        /// </summary>
        [Description("1009的2层检测光电")]
        public bool R_1009_High2 { get; set; }

        /// <summary>
        /// 1009的3层检测光电
        /// </summary>
        [Description("1009的3层检测光电")]
        public bool R_1009_High3 { get; set; }


        /// <summary>
        /// Station任务完成
        /// </summary>
        [Description("Station任务完成")]
        public bool R_Station_Finish { get; set; }


        /// <summary>
        /// Station当前坐标
        /// </summary>
        [Description("Station当前坐标")]
        public int R_Station_Coordinate { get; set; }

        #region è¯»çš„站点

        public List<StationDB2ObjForReadComm> R_StationForReadCommList { get; set; }

        #endregion

        

        #endregion
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/DB/RgvDBForRead.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,106 @@
using iWareSda.Devices._3_Station.StationModel;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareSda
{
    //Station地址类
    public class StationDBForRead
    {
        #region è¯»å–到的Station信息
        /// <summary>
        /// å¿ƒè·³
        /// </summary>
        [Description("心跳")]
        public string R_HandShake { get; set; }


        /// <summary>
        /// 1015扫码
        /// </summary>
        [Description("1015扫码")]
        public string R_1015_Scan { get; set; }

        /// <summary>
        /// 1019扫码
        /// </summary>
        [Description("1019扫码")]
        public string R_1019_Scan { get; set; }

        /// <summary>
        /// 1019发动机的扫码
        /// </summary>
        [Description("1019发动机的扫码")]
        public string R_1019_CargoNoScan { get; set; }

        /// <summary>
        /// 1002扫码
        /// </summary>
        [Description("1002扫码")]
        public string R_1002_Scan { get; set; }

        /// <summary>
        /// 1004扫码
        /// </summary>
        [Description("1004扫码")]
        public string R_1004_Scan { get; set; }

        /// <summary>
        /// 1006扫码
        /// </summary>
        [Description("1006扫码")]
        public string R_1006_Scan { get; set; }


        /// <summary>
        /// 1007扫码
        /// </summary>
        [Description("1007扫码")]
        public string R_1007_Scan { get; set; }

        /// <summary>
        /// 1009的1层检测光电
        /// </summary>
        [Description("1009的1层检测光电")]
        public string R_1009_High1 { get; set; }

        /// <summary>
        /// 1009的2层检测光电
        /// </summary>
        [Description("1009的2层检测光电")]
        public string R_1009_High2 { get; set; }

        /// <summary>
        /// 1009的3层检测光电
        /// </summary>
        [Description("1009的3层检测光电")]
        public string R_1009_High3 { get; set; }

        /// <summary>
        /// Station任务完成
        /// </summary>
        [Description("Station任务完成")]
        public string R_Station_Finish { get; set; }


        /// <summary>
        /// Station当前坐标
        /// </summary>
        [Description("Station当前坐标")]
        public string R_Station_Coordinate { get; set; }

        #region è¯»çš„站点

        public List<StationDBForReadComm> R_StationForReadCommList { get; set; }

        #endregion

        

        #endregion
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/DB/RgvDBForWrite.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,121 @@
using iWareSda.Devices._3_Station.StationModel;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareSda
{
    //Station地址类
    public class StationDBForWrite
    {

        #region å†™å…¥çš„Station信息
        /// <summary>
        /// å¿ƒè·³
        /// </summary>
        [Description("心跳")]
        public string W_HandShake { get; set; }

        /// <summary>
        /// 1015重新扫码，写为true表示重新扫码，写为false，表示关闭重新扫码。当wcs读到值后，就写为false
        /// </summary>
        [Description("1015重新扫码")]
        public string W_1015_ReScan { get; set; }

        /// <summary>
        /// 1019重新扫码，写为true表示重新扫码，写为false，表示关闭重新扫码。当wcs读到值后，就写为false
        /// </summary>
        [Description("1019重新扫码")]
        public string W_1019_ReScan { get; set; }

        /// <summary>
        /// Station_完成ACK
        /// </summary>
        [Description("Station_完成ACK")]
        public string W_Station_FinishACK { get; set; }


        /// <summary>
        /// 1002扫描失败信号
        /// </summary>
        [Description("1002扫描失败信号")]
        public string W_1002_ScanFailACK { get; set; }

        /// <summary>
        /// 1004扫描失败信号
        /// </summary>
        [Description("1004扫描失败信号")]
        public string W_1004_ScanFailACK { get; set; }

        /// <summary>
        /// 1006扫描失败信号
        /// </summary>
        [Description("1006扫描失败信号")]
        public string W_1006_ScanFailACK { get; set; }

        /// <summary>
        /// 1007扫描失败信号
        /// </summary>
        [Description("1007扫描失败信号")]
        public string W_1007_ScanFailACK { get; set; }


        /// <summary>
        /// 1002扫描成功信号
        /// </summary>
        [Description("1002扫描成功信号")]
        public string W_1002_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1004扫描成功信号
        /// </summary>
        [Description("1004扫描成功信号")]
        public string W_1004_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1006扫描成功信号
        /// </summary>
        [Description("1006扫描成功信号")]
        public string W_1006_ScanSuccessACK { get; set; }

        /// <summary>
        /// 1007扫描成功信号
        /// </summary>
        [Description("1007扫描成功信号")]
        public string W_1007_ScanSuccessACK { get; set; }


        /// <summary>
        /// å‡ºåº“发动机的型号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的型号")]
        public string W_Out_MaterialModel { get; set; }

        /// <summary>
        /// å‡ºåº“发动机的订货号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的订货号")]
        public string W_Out_OrderNo { get; set; }

        /// <summary>
        /// å‡ºåº“发动机的编号 ã€Editby shaocx,2023-07-23】
        /// </summary>
        [Description("出库发动机的编号")]
        public string W_Out_SerialNumber { get; set; }




        #region å†™çš„站点

        public List<StationDBForWriteComm> W_StationForWriteCommList { get; set; }

        #endregion


        #endregion
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/StationEntity.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,779 @@


using iWareSda.Common;
using System.Linq;
using iWareModel;
using System;
using System.Collections.Generic;
using System.Threading;
using iWareCommon.Utils;
using iWareCommon.Common.Globle;
using iWareCommon;
using iWareSda.Devices._3_Station.StationModel;
using Newtonsoft.Json;
using iWareSda.Model;


namespace iWareSda
{
    public class StationEntity : IDevice
    {
        public StationEntity()
        {

        }

        #region OPC相关

        /// <summary>
        /// å†™çš„DB块
        /// </summary>
        public StationDBForWrite DBBlockForWrite { get; set; }

        /// <summary>
        /// è¯»çš„DB块
        /// </summary>
        public StationDBForRead DBBlockForRead { get; set; }

        /// <summary>
        /// è¯»å–PLC实例
        /// </summary>
        public PLCService plcService { get; set; }

        /// <summary>
        /// è§†å›¾å¯¹è±¡
        /// </summary>
        public StationView View { get; set; }


        #endregion


        /// <summary>
        /// åˆå§‹åŒ–数据
        /// </summary>
        public void InitData()
        {


        }
        public StationEntity(string srmName, int deviceId, StationDBForWrite _dbBlockForWrite, StationDBForRead _dbBlockForRead, PLCService _plcService)
        {
            this.View = new StationView();
            this.View.DeviceName = srmName;
            this.View.DeviceId = deviceId;

            //集合赋值初始化
            this.View.R_StationForReadCommList = new List<StationDB2ObjForReadComm>();
            this.View.W_StationForWriteCommList = new List<StationDB2ObjForWriteComm>();
            for (int i = 0; i < WareSdaStruct.StationStationList.Count; i++)
            {
                this.View.R_StationForReadCommList.Add(new StationDB2ObjForReadComm() { StationCode = WareSdaStruct.StationStationList[i] });
                this.View.W_StationForWriteCommList.Add(new StationDB2ObjForWriteComm() { StationCode = WareSdaStruct.StationStationList[i] });
            }

            plcService = _plcService;
            DBBlockForWrite = _dbBlockForWrite;
            DBBlockForRead = _dbBlockForRead;
        }


        #region ä¸ªæ€§åŒ–方法

        /// <summary>
        /// Station任务发送
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskId"></param>
        /// <param name="sourcePlce"></param>
        /// <param name="toPlace"></param>
        /// <param name="taskType"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool SendTask(int deviceId, int taskId, string sourcePlce, string toPlace, out string msg)
        {
            try
            {
                msg = "";
                if (!CanSendTask(deviceId, out msg))
                {
                    return false;
                }

                //这里特殊转换一下
                if (toPlace == ((int)EDevice.出库口1012).ToString())
                {
                    toPlace = ((int)EDevice.提升机1030).ToString();
                }


                StationDBForWriteComm w_db_source = this.DBBlockForWrite.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == sourcePlce);
                StationDB2ObjForWriteComm w_dbObj_source = this.View.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == sourcePlce);

                //StationDBForWriteComm w_db_to = this.DBBlockForWrite.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == toPlace);
                //StationDB2ObjForWriteComm w_dbObj_to = this.View.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == toPlace);
                //如果ACK为true，表示不能发任务
                var readObj = this.View.R_StationForReadCommList.FirstOrDefault(x => x.StationCode == sourcePlce);
                if (readObj.R_ACK == true)
                {
                    msg = "ACK为TRUE，不允许发任务";
                    return false;
                }

                MessageModel b2 = null;
                if (!b2.result)
                {
                    msg = string.Format("向Station{0},起点{1}发送任务{2},写入目标站点{3}失败,返回结果:" + b2.resMsg, this.View.DeviceName, sourcePlce, taskId, toPlace);
                    return false;
                }
                b2 = this.plcService.WriteValuePoint(w_db_source.W_TaskID, Convert.ToInt32(taskId), w_dbObj_source.W_TaskID);
                if (!b2.result)
                {
                    msg = string.Format("向Station{0},起点{1}，目标点{2},写入任务号{3}失败,返回结果:" + b2.resMsg, this.View.DeviceName, sourcePlce, toPlace, taskId);
                    return false;
                }
              

                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, "发送任务出现异常:" + ex.Message, ex);
                return false;
            }
        }


        /// <summary>
        /// ä»»åŠ¡ä¸‹å‘确认(收到PLC反馈后WCS清除）
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool WriteStp(int deviceId, string stationCode, bool value, out string msg)
        {
            try
            {
                msg = "";
                StationDBForWriteComm w_db = this.DBBlockForWrite.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == stationCode);
                StationDB2ObjForWriteComm w_dbObj = this.View.W_StationForWriteCommList.FirstOrDefault(x => x.StationCode == stationCode);
                MessageModel b2 = null;
                if (!b2.result)
                {
                    msg = string.Format("向Station{0},站点号{1}写 ä»»åŠ¡ä¸‹å‘确认(收到PLC反馈后WCS清除） " + value + "失败,返回结果:" + b2.resMsg,
                        this.View.DeviceName, stationCode);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = string.Format("向Station{0},站点号{1}写 ä»»åŠ¡ä¸‹å‘确认(收到PLC反馈后WCS清除） " + true + "出现异常:" + JsonConvert.SerializeObject(ex),
                        deviceId, stationCode);
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }


        /// <summary>
        /// 1015重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool Write1015ReScan(int deviceId, bool value, out string msg)
        {
            try
            {
                msg = "";
                MessageModel b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_1015_ReScan, value, this.View.W_1015_ReScan);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_1015_ReScan);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = string.Format("向Station地址{0}  " + value + "出现异常:" + JsonConvert.SerializeObject(ex),
                        this.DBBlockForWrite.W_1015_ReScan);
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }

        /// <summary>
        /// 1019重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool Write1019ReScan(int deviceId, bool value, out string msg)
        {
            try
            {
                msg = "";
                MessageModel b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_1019_ReScan, value, this.View.W_1019_ReScan);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_1019_ReScan);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = string.Format("向Station地址{0}  " + value + "出现异常:" + JsonConvert.SerializeObject(ex),
                        this.DBBlockForWrite.W_1019_ReScan);
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }

        /// <summary>
        ///  Station的任务完成ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool WriteStation_FinishACK(int deviceId, bool value, int plcTaskId, out string msg)
        {
            try
            {
                msg = "";
                Thread.Sleep(1000);//停留2秒
                MessageModel b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_Station_FinishACK, value, this.View.W_Station_FinishACK);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_Station_FinishACK);
                    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                    return false;
                }
                //重新再读取，判断是否写入正确，如果写入不正确，就认为失败 ã€Editby shaocx,2023-04-03】
                Thread.Sleep(1000);//停留3秒
                bool finishStation = (bool)this.plcService.ReadValuePoint(this.DBBlockForRead.R_Station_Finish, typeof(bool));
                bool finisAck = (bool)this.plcService.ReadValuePoint(this.DBBlockForWrite.W_Station_FinishACK, typeof(bool));
                if (finisAck == false && finishStation == true)
                {
                    this.plcService.WriteValuePoint(this.DBBlockForWrite.W_Station_FinishACK, value, this.View.W_Station_FinishACK);//重发一次 20230503 çŽ‹é“®
                    Thread.Sleep(1000);//停留2秒
                    finishStation = (bool)this.plcService.ReadValuePoint(this.DBBlockForRead.R_Station_Finish, typeof(bool));
                    finisAck = (bool)this.plcService.ReadValuePoint(this.DBBlockForWrite.W_Station_FinishACK, typeof(bool));
                    if (finisAck == false && finishStation == true)
                    {

                        msg = string.Format("向Station地址{0} å†™  " + value + "失败,SDA返回结果:true，但是SDA再次读取PLC的地址时，获取的结果是FALSE，即认定为写入失败",
                                            this.DBBlockForWrite.W_Station_FinishACK);
                        Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                        return false;
                    }


                }

                Log4NetHelper.WriteInfoLog(Station_CacheEntity.curLogType, "写入W_Station_FinishACK（" + this.DBBlockForWrite.W_Station_FinishACK + "）值为" + value + "成功！因为PLC任务号:" + plcTaskId);
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = string.Format("向Station地址{0}  " + value + "出现异常:" + JsonConvert.SerializeObject(ex),
                        this.DBBlockForWrite.W_Station_FinishACK);
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }


        /// <summary>
        ///  å››ä¸ªå…¥åº“口扫描验证ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool WriteScanValidateACK(bool isReset, int deviceId, string stationCode, bool value, int plcTaskId, out string msg)
        {
            msg = "";
            MessageModel b2 = null;
            string address_fail = "";
            string address_success = "";
            try
            {
                switch (stationCode)
                {
                    case "1002":
                        address_fail = this.DBBlockForWrite.W_1002_ScanFailACK;
                        address_success = this.DBBlockForWrite.W_1002_ScanSuccessACK;
                        break;
                    case "1004":
                        address_fail = this.DBBlockForWrite.W_1004_ScanFailACK;
                        address_success = this.DBBlockForWrite.W_1004_ScanSuccessACK;
                        break;
                    case "1006":
                        address_fail = this.DBBlockForWrite.W_1006_ScanFailACK;
                        address_success = this.DBBlockForWrite.W_1006_ScanSuccessACK;
                        break;
                    case "1007":
                        address_fail = this.DBBlockForWrite.W_1007_ScanFailACK;
                        address_success = this.DBBlockForWrite.W_1007_ScanSuccessACK;
                        break;
                    default:
                        throw new Exception("不支持的站点");
                }
                if (isReset)
                {//是重置
                    b2 = this.plcService.WriteValuePoint(address_success, false, this.View.W_1002_ScanSuccessACK);
                    if (!b2.result)
                    {
                        msg = string.Format("向Station地址{0} å†™  " + false + "失败,返回结果:" + b2.resMsg,
                           address_success);
                        Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                        return false;
                    }
                    b2 = this.plcService.WriteValuePoint(address_fail, false, this.View.W_1002_ScanFailACK);
                    if (!b2.result)
                    {
                        msg = string.Format("向Station地址{0} å†™  " + false + "失败,返回结果:" + b2.resMsg,
                           address_fail);
                        Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                        return false;
                    }
                }
                else
                {//不是重置
                    if (value)
                    {//表示扫描验证通过
                        b2 = this.plcService.WriteValuePoint(address_success, true, this.View.W_1002_ScanSuccessACK);
                        if (!b2.result)
                        {
                            msg = string.Format("向Station地址{0} å†™  " + true + "失败,返回结果:" + b2.resMsg,
                               address_success);
                            Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                            return false;
                        }
                    }
                    else
                    {//表示扫描验证不通过
                        b2 = this.plcService.WriteValuePoint(address_fail, true, this.View.W_1002_ScanFailACK);
                        if (!b2.result)
                        {
                            msg = string.Format("向Station地址{0} å†™  " + true + "失败,返回结果:" + b2.resMsg,
                               address_fail);
                            Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                            return false;
                        }
                    }
                }

                Log4NetHelper.WriteInfoLog(Station_CacheEntity.curLogType, "WriteScanFailACK方法，写入 å››ä¸ªå…¥åº“口扫描失败ACK赋值 ScanFailACK（" + address_fail + "）值为" + value + "成功！因为PLC任务号:" + plcTaskId + ",isReset:" + isReset);
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = string.Format("WriteScanFailACK方法，向Station地址{0}  " + value + "出现异常:" + JsonConvert.SerializeObject(ex),
                       address_fail);
                if (value)
                {
                    logcontext = string.Format("WriteScanFailACK方法，向Station地址{0}  " + value + "出现异常:" + JsonConvert.SerializeObject(ex),
                       address_success);
                }
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }


        /// <summary>
        /// å–消报警
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool ClearAlarm(int deviceId, out string msg)
        {
            msg = "";
            return true;
            //try
            //{
            //    msg = "";
            //    var dbNumber = Station_CacheEntity.W_DBHeader;
            //    MessageModel b2 = this.plcService.WriteValuePoint( this.DBBlockForWrite.W_Reset, true, this.View.W_Reset);
            //    if (!b2.result)
            //    {
            //        msg = string.Format("向Station{0}写入设备复位" + true + "失败,返回结果:" + b2.resMsg, this.View.DeviceName);
            //        return false;
            //    }
            //    return true;
            //}
            //catch (Exception ex)
            //{
            //    msg = ex.Message;
            //    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, "取消报警出现异常:" + ex.Message, ex);
            //    return false;
            //}
        }

        /// <summary>
        /// ä»»åŠ¡åˆ é™¤
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskId"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool DeleteTask(int deviceId, int taskId, out string msg)
        {
            msg = "";
            return true;
            //try
            //{
            //    msg = "";
            //    if (this.View.R_TaskNo != taskId)
            //    {
            //        msg = string.Format("Station当前非执行taskId={0}的任务", taskId);
            //        return false;
            //    }
            //    var dbNumber = Station_CacheEntity.W_DBHeader;
            //    MessageModel b2 = this.plcService.WriteValuePoint( this.DBBlockForWrite.W_TaskNo, taskId, this.View.W_TaskNo);
            //    if (!b2.result)
            //    {
            //        msg = string.Format("向Station{0}写入任务号" + taskId + "失败,返回结果:" + b2.resMsg, this.View.DeviceName);
            //        return false;
            //    }
            //    b2 = this.plcService.WriteValuePoint( this.DBBlockForWrite.W_Reset, 1, this.View.W_Reset);
            //    if (!b2.result)
            //    {
            //        msg = string.Format("向Station{0}写入设备复位" + 1 + "失败,返回结果:" + b2.resMsg, this.View.DeviceName);
            //        return false;
            //    }
            //    return true;
            //}
            //catch (Exception ex)
            //{
            //    msg = ex.Message;
            //    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, "任务删除出现异常:" + ex.Message, ex);
            //    return false;
            //}
        }

        /// <summary>
        /// æ€¥åœ
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool EmergencyStop(int deviceId, string stationCode, out string msg)
        {
            msg = "";
            return true;
            //try
            //{
            //    msg = "";
            //    var dbNumber = Station_CacheEntity.W_DBHeader;
            //    MessageModel b2 = this.plcService.WriteValuePoint( this.DBBlockForWrite.W_StationForWriteCommList.Find(x => x.StationCode == stationCode)., 1, this.View.W_EStop);
            //    if (!b2.result)
            //    {
            //        msg = string.Format("向Station{0}写入急停" + 1 + "失败,返回结果:" + b2.resMsg, this.View.DeviceName);
            //        return false;
            //    }
            //    return true;
            //}
            //catch (Exception ex)
            //{
            //    msg = ex.Message;
            //    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, "急停出现异常:" + ex.Message, ex);
            //    return false;
            //}
        }

        /// <summary>
        /// æ˜¯å¦å¯ä»¥å‘送任务
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskType"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool CanSendTask(int deviceId, out string msg)
        {
            msg = "";
            //模拟
            //if (!this.View.IsConnected)
            //{
            //    msg = "已离线";
            //    return false;
            //}
            //if (this.View.R_Mode != (int)EStationMode.连机自动模式)
            //{
            //    msg = "当前非自动模式";
            //    return false;
            //}
            //if (this.View.R_State != (int)EStationState.空闲)
            //{
            //    msg = "设备状态非空闲，无法执行其他任务";
            //    return false;
            //}
            return true;
        }

        /// <summary>
        /// Station是否是自动待机模式
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool StationIsAutoAwaitMode(string stationCode, out string msg)
        {
            msg = "";
            var readData = this.View.R_StationForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (readData.R_Model != (int)EStationMode.自动待机模式)
            {
                EStationMode mode = (EStationMode)Enum.Parse(typeof(EStationMode), readData.R_Model.ToString());
                msg = "站点" + stationCode + " å½“前模式是[" + mode.ToString() + "],非自动待机模式";
                return false;
            }
            return true;
        }

        /// <summary>
        /// Station是否是自动模式
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool StationIsAuto(string stationCode, out string msg)
        {
            msg = "";
            var readData = this.View.R_StationForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (readData.R_Model != (int)EStationMode.自动待机模式 && readData.R_Model != (int)EStationMode.自动运行模式)
            {
                EStationMode mode = (EStationMode)Enum.Parse(typeof(EStationMode), readData.R_Model.ToString());
                msg = "站点" + stationCode + " å½“前模式是[" + mode.ToString() + "],非自动待机模式或自动运行模式";
                return false;
            }
            return true;
        }

        /// <summary>
        /// Station是否是空闲状态
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool StationIsStateFree(string stationCode, out string msg)
        {
            msg = "";
            var readData = this.View.R_StationForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();
            if (readData.R_State != (int)EStationState.空闲)
            {
                EStationMode mode = (EStationMode)Enum.Parse(typeof(EStationMode), readData.R_Model.ToString());
                msg = "站点" + stationCode + " å½“前状态是[" + mode.ToString() + "],非空闲";
                return false;
            }
            return true;
        }

        /// <summary>
        ///  å‘动机出库，给西港PLC发送发动机数据 ã€Editby shaocx,2023-07-23】
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool WriteStation_XigangGetDataForOut(int deviceId, string value__Out_MaterialModel,
            string value_Out_OrderNo,
            string value_Out_SerialNumber,
            int plcTaskId, out string msg)
        {
            try
            {
                msg = "";
                MessageModel b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_Out_MaterialModel, value__Out_MaterialModel, this.View.W_Out_MaterialModel);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value__Out_MaterialModel + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_Out_MaterialModel);
                    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                    return false;
                }
                b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_Out_OrderNo, value_Out_OrderNo, this.View.W_Out_OrderNo);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value_Out_OrderNo + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_Out_OrderNo);
                    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                    return false;
                }
                b2 = this.plcService.WriteValuePoint(this.DBBlockForWrite.W_Out_SerialNumber, value_Out_SerialNumber, this.View.W_Out_SerialNumber);
                if (!b2.result)
                {
                    msg = string.Format("向Station地址{0} å†™  " + value_Out_SerialNumber + "失败,返回结果:" + b2.resMsg,
                        this.DBBlockForWrite.W_Out_SerialNumber);
                    Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, msg, null);
                    return false;
                }


                Log4NetHelper.WriteInfoLog(Station_CacheEntity.curLogType, $"写入 å‘动机出库，给西港PLC发送发动机数据成功！任务号{plcTaskId},机型{value__Out_MaterialModel}，订货号{value_Out_OrderNo},编号{value_Out_SerialNumber}" + plcTaskId);
                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                var logcontext = $"任务号{plcTaskId},机型{value__Out_MaterialModel}，订货号{value_Out_OrderNo},编号{value_Out_SerialNumber},写入 å‘动机出库，给西港PLC发送发动机数据出现异常:" + JsonConvert.SerializeObject(ex);
                Log4NetHelper.WriteErrorLog(Station_CacheEntity.curLogType, logcontext, ex);
                return false;
            }
        }

        #endregion

        public void SetPropertyValueForRead()
        {
            var r_dbBlock = this.DBBlockForRead;
            SdaHelper.SetPropertyValueForDB<StationDBForRead, StationView>(r_dbBlock, this.View, this.plcService, "");
            //特殊处理List集合
            foreach (var item in r_dbBlock.R_StationForReadCommList)
            {
                StationDB2ObjForReadComm StationDB2ObjForReadComm = this.View.R_StationForReadCommList.Where(x => x.StationCode == item.StationCode).First();
                SdaHelper.SetPropertyValueForDB<StationDBForReadComm, StationDB2ObjForReadComm>(item, StationDB2ObjForReadComm, this.plcService, "");
            }
            //这里特殊处理 è¯»å–的发动机码 
            this.View.R_1019_CargoNoScan = GetNewCategoryNo(this.View.R_1019_CargoNoScan);
        }


        public void SetPropertyValueForWrite()
        {
            var w_dbBlock = this.DBBlockForWrite;
            SdaHelper.SetPropertyValueForDB<StationDBForWrite, StationView>(w_dbBlock, this.View, this.plcService, "");
            //特殊处理List集合
            foreach (var item in w_dbBlock.W_StationForWriteCommList)
            {
                StationDB2ObjForWriteComm StationDB2ObjForWriteComm = this.View.W_StationForWriteCommList.Where(x => x.StationCode == item.StationCode).First();
                SdaHelper.SetPropertyValueForDB<StationDBForWriteComm, StationDB2ObjForWriteComm>(item, StationDB2ObjForWriteComm, this.plcService, "");
            }
        }

        /// <summary>
        /// æ˜¯å¦æœ‰å¿ƒè·³
        /// </summary>
        /// <returns></returns>
        public bool IsHaveHeatBeat()
        {
            try
            {
                var r_dbBlock = this.DBBlockForRead;
                short value = Convert.ToInt16(this.plcService.ReadValuePoint(r_dbBlock.R_HandShake, typeof(short)));
                //约定 ç­‰å¾…2秒
                Thread.Sleep(2000);
                short value_next = Convert.ToInt16(this.plcService.ReadValuePoint(r_dbBlock.R_HandShake, typeof(short)));
                if (value == value_next)
                {//没有心跳
                    return false;
                }
                else
                {//有心跳
                    return true;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #region èŽ·å–当前报警信息


        /// <summary>
        /// èŽ·å–Station当前报警信息
        /// </summary>
        /// <returns></returns>
        public List<DeviceWarningInfo> GetStationAlertDatas()
        {
            List<DeviceWarningInfo> db_warningList = new List<DeviceWarningInfo>();
            try
            {
                string _dbValue;
                var isHasAlert = false;
                IDictionary<string, string> StationAlertDict = new Dictionary<string, string>();
                StationAlertDict = WareSdaStruct.StationAlertDict;
                foreach (var item in StationAlertDict)
                {
                    _dbValue = item.Key;
                    isHasAlert = Convert.ToBoolean(this.plcService.ReadValuePoint(Station_CacheEntity.R_DBHeader_Station_Alert, item.Key, typeof(bool)));
                    if (isHasAlert)
                    {
                        db_warningList.Add(new DeviceWarningInfo()
                        {
                            Address = item.Key,
                            Code = item.Key,
                            Context = item.Value.Trim()
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return db_warningList;
        }

        /// <summary>
        /// èŽ·å–输送线当前报警信息
        /// </summary>
        /// <returns></returns>
        public List<DeviceWarningInfo> GetLineAlertDatas()
        {
            List<DeviceWarningInfo> db_warningList = new List<DeviceWarningInfo>();
            try
            {
                IDictionary<string, string> srmAlertDict = new Dictionary<string, string>();
                foreach (var item in this.View.R_StationForReadCommList)
                {
                    if (item.R_AlarmCode > 0)
                    {
                        item.R_AlarmCodeMsg = WareSdaStruct.StationAlertDict[item.R_AlarmCode.ToString()];
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return db_warningList;
        }


        #endregion

        /// <summary>
        /// ç‰¹æ®Šå¤„理下 è¯»å–的发动机码
        /// </summary>
        /// <param name="orgCategoryNo"></param>
        /// <returns></returns>
        private string GetNewCategoryNo(string orgCategoryNo)
        {
            Log4NetHelper.WriteInfoLog(Station_CacheEntity.curLogType, "读取的发动机码,原始读取的值:" + orgCategoryNo);
            //如果有 $R内容，就替换为空
            var repStr = "$R";
            if (!string.IsNullOrEmpty(orgCategoryNo) && orgCategoryNo.IndexOf(repStr) > -1)
            {
                orgCategoryNo = orgCategoryNo.Replace(repStr, "");
            }
            Log4NetHelper.WriteInfoLog(Station_CacheEntity.curLogType, "读取的发动机码,替换后的值:" + orgCategoryNo);
            return orgCategoryNo;
        }
    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/StationView.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,43 @@

using iWareSda.Model;
using System.Collections.Generic;
using System.ComponentModel;
namespace iWareSda
{
    /// <summary>
    /// Station展示实体类
    /// </summary>
    public class StationView : StationDB2Obj
    {
        /// <summary>
        /// è®¾å¤‡åç§°
        /// </summary>
        [Description("设备名称")]
        public string DeviceName { get; set; }
        /// <summary>
        /// è®¾å¤‡ç¼–号
        /// </summary>
        [Description("设备编号")]
        public int DeviceId { get; set; }

        /// <summary>
        /// æ˜¯å¦å·²ç»è¿žæŽ¥
        /// </summary>
        [Description("是否已经连接")]
        public bool IsConnected { get; set; }


        /// <summary>
        /// è¾“送线报警DB集合
        /// </summary>
        [Description("报警DB集合")]
        public List<DeviceWarningInfo> R_Line_WarningDBList { get; set; }

        /// <summary>
        /// Station报警DB集合
        /// </summary>
        [Description("Station报警DB集合")]
        public List<DeviceWarningInfo> R_Station_WarningDBList { get; set; }

    }
}

 SDA/iWareSda/Devices/4-Station/StationModel/Station_CacheEntity.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,314 @@
using iWareCommon.Utils;
using iWareModel;
using iWareSda.Devices._3_Station.StationModel;
using System;
using System.Collections.Generic;
using System.Linq;

namespace iWareSda
{
    /// <summary>
    /// Station实体类
    /// </summary>
    public static class Station_CacheEntity
    {
        public static LogType curLogType = LogType.StationSdaService;

        #region Station1

        /// <summary>
        /// å†™å…¥DB
        /// </summary>
        public static string W_DBHeaderWithSeparate = "610" + WareSdaStruct.PLCDBADDRESS_SEPARATE;
        /// <summary>
        /// è¯»å–DB
        /// </summary>
        public static string R_DBHeaderWithSeparate = "600" + WareSdaStruct.PLCDBADDRESS_SEPARATE;

        /// <summary>
        /// è¯»å–DB(扫码)
        /// </summary>
        public static string R_DBHeader_ScanWithSeparate = "80" + WareSdaStruct.PLCDBADDRESS_SEPARATE;

        /// <summary>
        /// è¯»å–DB(报警专用)
        /// </summary>
        public static string R_DBHeader_Alert = "91" + WareSdaStruct.PLCDBADDRESS_SEPARATE;

        /// <summary>
        /// è¯»å–DB(Station报警专用)
        /// </summary>
        public static string R_DBHeader_Station_Alert = "1090";


        /// <summary>
        /// è¥¿æ¸¯æ–¹é‡‡é›†å‡ºåº“发动机数据，写入DB ã€Editby shaocx,2023-07-23】
        /// </summary>
        public static string W_DBHeaderForXigangGetDataWithSeparate = "3" + WareSdaStruct.PLCDBADDRESS_SEPARATE;

        private static StationDBForWrite _dbBlockForWrite = SetW_StationForWriteCommList();


        private static StationDBForRead _dbBlockForRead = SetR_StationForWriteCommList();


        private static HslCommunicationParam hslCommunicationParam = new HslCommunicationParam()
        {
            cpu = WareSdaStruct.Station_SiemensPLCS,
            ip = WareSdaStruct.Station_Address,
            rack = WareSdaStruct.Station_Rack,
            slot = WareSdaStruct.Station_Slot,
            port = WareSdaStruct.Station_Port
        };
        private static SS7Param s7Param = new SS7Param()
        {
            cpu = WareSdaStruct.Station_PLC_CpuType,
            ip = WareSdaStruct.Station_Address,
            rack = WareSdaStruct.Station_Rack,
            slot = WareSdaStruct.Station_Slot,
        };
        private static PLCService PLCService = PLCFactory.GetOPCService(WareSdaStruct.System_PlcServiceTypeEnum, s7Param, hslCommunicationParam);
        private static StationEntity Station = new StationEntity("Station", (int)EDevice.Station, _dbBlockForWrite, _dbBlockForRead, PLCService);

        #endregion

        private static List<StationEntity> _deviceObjList = null;
        private static object objLock = new object();

        /// <summary>
        /// ç”Ÿæˆè®¾å¤‡å®žä½“ç±»
        /// </summary>
        public static List<StationEntity> DeviceObjs
        {
            get
            {
                if (_deviceObjList == null)
                {
                    lock (objLock)
                    {
                        if (_deviceObjList == null)
                        {
                            _deviceObjList = new List<StationEntity>();
                            _deviceObjList.Add(Station);
                        }
                    }
                }
                return Station_CacheEntity._deviceObjList;
            }
            set { Station_CacheEntity._deviceObjList = value; }
        }

        private static T GetDeviceObj<T>(int deviceId)
        {
            var device = Station_CacheEntity.DeviceObjs.FirstOrDefault(x => x.View.DeviceId == deviceId);
            return (T)(Object)device;
        }


        /// <summary>
        /// èŽ·å–设备对象
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public static SdaResEntity GetDeviceObj(int deviceId)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            StationEntity Station = Station_CacheEntity.GetDeviceObj<StationEntity>(deviceId);
            if (Station == null)
            {
                return SdaResEntity.Failure("没有找到Station设备");
            }
            return SdaResEntity.Success("成功", Station);
        }


        /// <summary>
        /// å†™å…¥åœ°å€é›†åˆèµ‹å€¼
        /// </summary>
        /// <param name="_dbBlockForWrite"></param>
        /// <param name="_dbBlockForRead"></param>
        private static StationDBForWrite SetW_StationForWriteCommList()
        {
            StationDBForWrite _dbBlockForWrite = new StationDBForWrite()
            {
                //TODO:这里写配置的DB地址
                #region å†™å…¥
                W_HandShake = W_DBHeaderWithSeparate + "0.0",
                W_1015_ReScan = R_DBHeader_ScanWithSeparate + "302.0", //1015位置重新扫码 ã€EditBy shaocx,2022-05-02】
                W_1019_ReScan = R_DBHeader_ScanWithSeparate + "368.0", //1019位置重新扫码， ã€EditBy shaocx,2022-05-02】
                W_Station_FinishACK = W_DBHeaderWithSeparate + "146.0",

                W_1002_ScanFailACK = R_DBHeader_ScanWithSeparate + "66.1",
                W_1004_ScanFailACK = R_DBHeader_ScanWithSeparate + "126.1",
                W_1006_ScanFailACK = R_DBHeader_ScanWithSeparate + "186.1",
                W_1007_ScanFailACK = R_DBHeader_ScanWithSeparate + "246.1",

                W_1002_ScanSuccessACK = R_DBHeader_ScanWithSeparate + "66.0",
                W_1004_ScanSuccessACK = R_DBHeader_ScanWithSeparate + "126.0",
                W_1006_ScanSuccessACK = R_DBHeader_ScanWithSeparate + "186.0",
                W_1007_ScanSuccessACK = R_DBHeader_ScanWithSeparate + "246.0",

                W_Out_MaterialModel = W_DBHeaderForXigangGetDataWithSeparate + "0.0",
                W_Out_OrderNo = W_DBHeaderForXigangGetDataWithSeparate + "18.0",
                W_Out_SerialNumber = W_DBHeaderForXigangGetDataWithSeparate + "36.0",
                #endregion
            };

            //写入地址
            _dbBlockForWrite.W_StationForWriteCommList = new List<StationDBForWriteComm>();

            _dbBlockForWrite.W_StationForWriteCommList.Add(new StationDBForWriteComm() { StationCode = "1001", W_TaskID = W_DBHeaderWithSeparate + "6.0" });
            _dbBlockForWrite.W_StationForWriteCommList.Add(new StationDBForWriteComm() { StationCode = "1002", W_TaskID = W_DBHeaderWithSeparate + "14.0" });
            _dbBlockForWrite.W_StationForWriteCommList.Add(new StationDBForWriteComm() { StationCode = "1003", W_TaskID = W_DBHeaderWithSeparate + "22.0" });



            return _dbBlockForWrite;
        }

        ///// <summary>
        ///// è¯»å–地址集合赋值
        ///// </summary>
        ///// <param name="_dbBlockForWrite"></param>
        ///// <param name="_dbBlockForRead"></param>
        //private static StationDBForWrite SetW_StationForWriteCommList2()
        //{
        //    StationDBForWrite _dbBlockForRead = new StationDBForWrite()
        //    {
        //        //TODO:这里写配置的DB地址
        //        #region è¯»å–
        //        W_HandShake = "0.0",

        //        #endregion
        //    };

        //    //读取地址
        //    double default_STP = 2.0;
        //    double default_Destination = 4.0;
        //    double default_TaskID = 6.0;

        //    int addValue = 16;
        //    _dbBlockForRead.W_StationForWriteCommList = new List<StationDBForWriteComm>();
        //    for (int i = 0; i < WareSdaStruct.StationStationList.Count; i++)
        //    {
        //        var stationCode = WareSdaStruct.StationStationList[i];
        //        if (i > 0)
        //        {
        //            default_STP += addValue;
        //            default_Destination += addValue;
        //            default_TaskID += addValue;
        //        }
        //        _dbBlockForRead.W_StationForWriteCommList.Add(new StationDBForWriteComm()
        //        {
        //            StationCode = stationCode,
        //            W_STP = default_STP.ToString("0.0"),
        //            W_Destination = default_Destination.ToString("0.0"),
        //            W_TaskID = default_TaskID.ToString("0.0"),
        //        });

        //    }

        //    return _dbBlockForRead;

        //}

        /// <summary>
        /// è¯»å–地址集合赋值
        /// </summary>
        /// <param name="_dbBlockForWrite"></param>
        /// <param name="_dbBlockForRead"></param>
        private static StationDBForRead SetR_StationForWriteCommList()
        {
            StationDBForRead _dbBlockForRead = new StationDBForRead()
            {
                //TODO:这里写配置的DB地址
                #region è¯»å–
                R_HandShake = R_DBHeaderWithSeparate + "0.0",

                //注意：这里用的扫描的地址块
                R_1015_Scan = R_DBHeader_ScanWithSeparate + "48.0",
                R_1019_Scan = R_DBHeader_ScanWithSeparate + "356.0",
                R_1019_CargoNoScan = R_DBHeader_ScanWithSeparate + "378.0",
                R_1002_Scan = R_DBHeader_ScanWithSeparate + "108.0",
                R_1004_Scan = R_DBHeader_ScanWithSeparate + "168.0",
                R_1006_Scan = R_DBHeader_ScanWithSeparate + "228.0",
                R_1007_Scan = R_DBHeader_ScanWithSeparate + "288.0",
                R_1009_High1 = R_DBHeader_ScanWithSeparate + "300.0",
                R_1009_High2 = R_DBHeader_ScanWithSeparate + "300.1",
                R_1009_High3 = R_DBHeader_ScanWithSeparate + "300.2",

                R_Station_Finish = R_DBHeaderWithSeparate + "349.0",

                R_Station_Coordinate = R_DBHeader_ScanWithSeparate + "304.0"

                #endregion
            };

            //读取地址
            double default_PH_1 = 2.0;
            double default_PH_2 = 2.1;
            double default_ACK = 2.2;
            double default_Model = 4.0;
            double default_State = 6.0;
            double default_AlarmCode = 8.0;
            double default_Destination = 10.0;
            double default_Shape = 12.0;
            double default_TaskID = 14.0;
            int addValue = 16;
            _dbBlockForRead.R_StationForReadCommList = new List<StationDBForReadComm>();
            for (int i = 0; i < WareSdaStruct.StationStationList.Count; i++)
            {
                var stationCode = WareSdaStruct.StationStationList[i];
                if (stationCode == "1019")
                {
                    _dbBlockForRead.R_StationForReadCommList.Add(new StationDBForReadComm()
                    {
                        StationCode = stationCode,
                        R_PH_1 = R_DBHeaderWithSeparate + "350.0",
                        R_PH_2 = R_DBHeaderWithSeparate + "350.1",
                        R_ACK = R_DBHeaderWithSeparate + "350.2",
                        R_Model = R_DBHeaderWithSeparate + ("352.0"),
                        R_State = R_DBHeaderWithSeparate + ("354.0"),
                        R_AlarmCode = R_DBHeaderWithSeparate + ("356.0"),
                        R_Destination = R_DBHeaderWithSeparate + ("358.0"),
                        R_Shape = R_DBHeaderWithSeparate + ("360.0"),
                        R_TaskID = R_DBHeaderWithSeparate + ("362.0")
                    });
                }
                else
                {
                    if (i > 0)
                    {
                        default_PH_1 += addValue;
                        default_PH_2 += addValue;
                        default_ACK += addValue;
                        default_Model += addValue;
                        default_State += addValue;
                        default_AlarmCode += addValue;
                        default_Destination += addValue;
                        default_Shape += addValue;
                        default_TaskID += addValue;
                    }
                    _dbBlockForRead.R_StationForReadCommList.Add(new StationDBForReadComm()
                    {
                        StationCode = stationCode,
                        R_PH_1 = R_DBHeaderWithSeparate + default_PH_1.ToString("0.0"),
                        R_PH_2 = R_DBHeaderWithSeparate + default_PH_2.ToString("0.0")
                        ,
                        R_ACK = R_DBHeaderWithSeparate + default_ACK.ToString("0.0"),
                        R_Model = R_DBHeaderWithSeparate + default_Model.ToString("0.0"),
                        R_State = R_DBHeaderWithSeparate + default_State.ToString("0.0"),
                        R_AlarmCode = R_DBHeaderWithSeparate + default_AlarmCode.ToString("0.0"),
                        R_Destination = R_DBHeaderWithSeparate + default_Destination.ToString("0.0"),
                        R_Shape = R_DBHeaderWithSeparate + default_Shape.ToString("0.0"),
                        R_TaskID = R_DBHeaderWithSeparate + default_TaskID.ToString("0.0")
                    });
                }
            }

            return _dbBlockForRead;

        }

    }
}

 SDA/iWareSda/Devices/4-Station/StationService/IStationService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,138 @@
using iWareModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace iWareSda
{
    // æ³¨æ„: ä½¿ç”¨â€œé‡æž„”菜单上的“重命名”命令，可以同时更改代码和配置文件中的接口名“IStationService”。
    [ServiceContract]
    public interface IStationService
    {
        /// <summary>
        /// è§£è­¦
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity ClearAlarm(int deviceId);

        /// <summary>
        /// ä¸‹å‘Station任务
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskId"></param>
        /// <param name="sourcePlce"></param>
        /// <param name="toPlace"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity SendStationTask(int deviceId, int taskId, string sourcePlce, string toPlace);

        /// <summary>
        /// ä»»åŠ¡ä¸‹å‘确认(收到PLC反馈后WCS清除）
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="stationCode"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity WriteStp(int deviceId, bool value, string stationCode);


        [OperationContract]
        StationView GetStationInfo(int deviceId);

        [OperationContract]
        SdaResEntity IsTaskFinish(int deviceId, int taskId);

        [OperationContract]
        SdaResEntity DeleteStationTask(int deviceId, int taskId);

        ///// <summary>
        ///// Station急停
        ///// </summary>
        ///// <param name="deviceId"></param>
        ///// <returns></returns>
        //[OperationContract]
        //SdaResEntity EmergencyStop(int deviceId);

        /// <summary>
        /// Station是否是自动模式
        /// </summary>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity IsStationAuto(int deviceId, string stationCode);

        /// <summary>
        /// åˆ¤æ–­Station是否可用，是否可以发送新任务给Station
        /// </summary>
        /// <param name="srmId"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity IsAllowSendTask(bool isNeedValidateRealSourceAndToPlace, int deviceId, string stationCode, string toStationCode, bool isStationTask);


        /// <summary>
        /// åˆ¤æ–­æ˜¯å¦æœ‰å¿ƒè·³
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity IsHaveHeatBeat(int deviceId);

        /// <summary>
        /// 1015重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity Write1015ReScan(int deviceId, bool value);

        /// <summary>
        /// 1019重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity Write1019ReScan(int deviceId, bool value);

        /// <summary>
        /// Station的任务完成ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity WriteStation_FinishACK(int deviceId, bool value, int plcTaskId);

        /// <summary>
        /// å››ä¸ªå…¥åº“口扫描验证ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity WriteScanValidateACK(bool isReset, int deviceId, string stationCode, bool value, int plcTaskId);

        /// <summary>
        /// å‘动机出库，给西港PLC发送发动机数据 ã€Editby shaocx,2023-07-23】
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value__Out_MaterialModel"></param>
        /// <param name="value_Out_OrderNo"></param>
        /// <param name="value_Out_SerialNumber"></param>
        /// <param name="plcTaskId"></param>
        /// <returns></returns>
        [OperationContract]
        SdaResEntity WriteStation_XigangGetDataForOut(int deviceId, string value__Out_MaterialModel,
           string value_Out_OrderNo,
           string value_Out_SerialNumber,
           int plcTaskId);

    }
}

 SDA/iWareSda/Devices/4-Station/StationService/StationService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,576 @@
using iWareCommon.Utils;
using iWareModel;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;


namespace iWareSda
{
    // æ³¨æ„: ä½¿ç”¨â€œé‡æž„”菜单上的“重命名”命令，可以同时更改代码和配置文件中的类名“StationService”。
    public class StationService : IStationService
    {
        public SdaResEntity ClearAlarm(int deviceId)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;
                string msg;
                var result = Station.ClearAlarm(deviceId, out msg);
                Log4NetHelper.WriteInfoLog(LogType.StationSdaService, "下发deviceId=" + deviceId + "的Station消警指令" + (result ? "成功" : "失败") + "原因：" + msg);
                sdaResult.result = result;
                sdaResult.resMsg = msg;
                return sdaResult;
            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                return sdaResult;
            }
        }


        /// <summary>
        /// ä¸‹å‘Station任务
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskId"></param>
        /// <param name="sourcePlce"></param>
        /// <param name="toPlace"></param>
        /// <param name="pallType"></param>
        /// <returns></returns>
        public SdaResEntity SendStationTask(int deviceId, int taskId, string sourcePlce, string toPlace)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                //如果STP为TRUE，表示不能发任务


                string msg;
                var result = Station.SendTask(deviceId, taskId, sourcePlce, toPlace, out msg);
                Log4NetHelper.WriteInfoLog(LogType.StationSdaService, "下发deviceId=" + deviceId + ",taskId=" + taskId + ",fromPlace=" +
                    sourcePlce + ",toPlace=" + toPlace + "的Station任务" + (result ? "成功" : "失败") + "原因：" + msg);

                sdaResult.result = result;
                sdaResult.resMsg = msg;
                return sdaResult;
            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                return sdaResult;
            }
        }

        /// <summary>
        /// ä»»åŠ¡ä¸‹å‘确认(收到PLC反馈后WCS清除）
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="stationCode"></param>
        /// <returns></returns>
        public SdaResEntity WriteStp(int deviceId, bool value, string stationCode)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.WriteStp(deviceId, stationCode, value, out msg);
                Log4NetHelper.WriteInfoLog(LogType.StationSdaService,
                    "下发deviceId=" + deviceId + "，站点号=" + stationCode + "的任务下发确认(收到PLC反馈后WCS清除）指令" + (result ? "成功" : "失败") + "原因：" + msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }

        public SdaResEntity DeleteStationTask(int deviceId, int taskId)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;
                string msg = "";
                var result = Station.DeleteTask(deviceId, taskId, out msg);
                Log4NetHelper.WriteInfoLog(LogType.StationSdaService, "下发deviceId = " + deviceId + "的删除Station任务指令" + (result ? "成功" : "失败") + "原因：" + msg);
                sdaResult.result = result;
                sdaResult.resMsg = msg;
                return sdaResult;
            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                return sdaResult;
            }
        }

        ///// <summary>
        ///// Station急停
        ///// </summary>
        ///// <param name="deviceId"></param>
        ///// <returns></returns>
        //public SdaResEntity EmergencyStop(int deviceId)
        //{
        //    SdaResEntity sdaResult = new SdaResEntity();
        //    try
        //    {
        //        var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
        //        if (!StationResult.result)
        //        {
        //            return StationResult;
        //        }
        //        var Station = StationResult.resData as StationEntity;

        //        string msg = "";
        //        var result = Station.EmergencyStop(deviceId, out msg);
        //        Log4NetHelper.WriteInfoLog(LogType.StationSdaService, "下发deviceId = " + deviceId + "的急停任务指令" + (result ? "成功" : "失败") + "原因：" + msg);
        //        sdaResult.result = result;
        //        sdaResult.resMsg = msg;
        //        return sdaResult;
        //    }
        //    catch (Exception ex)
        //    {
        //        sdaResult.result = false;
        //        sdaResult.resMsg = JsonConvert.SerializeObject(ex);
        //        return sdaResult;
        //    }
        //}

        /// <summary>
        /// èŽ·å–整个Station对象
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public StationView GetStationInfo(int deviceId)
        {
            var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
            if (!StationResult.result)
            {
                return null;
            }
            var Station = (StationResult.resData as StationEntity).View;
            return Station;
        }


        /// <summary>
        /// Station任务是否完成
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="taskId"></param>
        /// <returns></returns>
        public SdaResEntity IsTaskFinish(int deviceId, int taskId)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                var stationCode = "";
                var readData = Station.View.R_StationForReadCommList.Where(x => x.StationCode == stationCode).FirstOrDefault();

                sdaResult.result = readData.R_TaskID == taskId && Station.View.R_Station_Finish;
                sdaResult.resMsg = "成功";
            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                return sdaResult;
            }
            return sdaResult;
        }




        /// <summary>
        /// Station是否是自动模式
        /// </summary>
        /// <returns></returns>
        public SdaResEntity IsStationAuto(int deviceId, string stationCode)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                var msg = "";
                var result = Station.StationIsAuto(stationCode, out msg);
                if (!StationResult.result)
                {
                    sdaResult.result = false;
                    sdaResult.resMsg = msg;
                    return StationResult;
                }


                sdaResult.result = true;

            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                Log4NetHelper.WriteErrorLog(LogType.StationSdaService, "判断Station是否是自动模式出现异常,ex:" + JsonConvert.SerializeObject(ex), ex);
            }
            return sdaResult;
        }

        /// <summary>
        /// Station是否是自动待机模式
        /// </summary>
        /// <returns></returns>
        public SdaResEntity StationIsAutoAwaitMode(int deviceId, string stationCode)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                var msg = "";
                var result = Station.StationIsAutoAwaitMode(stationCode, out msg);
                if (!StationResult.result)
                {
                    sdaResult.result = false;
                    sdaResult.resMsg = msg;
                    return StationResult;
                }


                sdaResult.result = true;

            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = JsonConvert.SerializeObject(ex);
                Log4NetHelper.WriteErrorLog(LogType.StationSdaService, "判断Station是否是自动待机模式出现异常,ex:" + JsonConvert.SerializeObject(ex), ex);
            }
            return sdaResult;
        }


        /// <summary>
        /// åˆ¤æ–­Station是否可用，是否可以发送新任务给Station
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="sourceStationCode"></param>
        /// <param name="toStationCode"></param>
        /// <param name="isStationTask">是否是涉及到Station的任务</param>
        /// <returns></returns>
        public SdaResEntity IsAllowSendTask(bool isNeedValidateRealSourceAndToPlace, int deviceId, string sourceStationCode, string toStationCode, bool isStationTask)
        {
            var msg = "";
            SdaResEntity sdaResult = new SdaResEntity();
            try
            {

                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;
                var result = false;
                if (isNeedValidateRealSourceAndToPlace)
                {
                    //判断起点是否是自动待机模式
                    result = Station.StationIsAutoAwaitMode(sourceStationCode, out msg);
                    if (!result)
                    {
                        sdaResult.result = false;
                        sdaResult.resMsg = msg;
                        return sdaResult;
                    }
                    //判断起点是否是空闲状态
                    result = Station.StationIsStateFree(sourceStationCode, out msg);
                    if (!result)
                    {
                        sdaResult.result = false;
                        sdaResult.resMsg = msg;
                        return sdaResult;
                    }
                }


                if (isNeedValidateRealSourceAndToPlace)
                {
                    //判断目标点是否是自动模式
                    result = Station.StationIsAuto(toStationCode, out msg);
                    if (!result)
                    {
                        sdaResult.result = false;
                        sdaResult.resMsg = msg;
                        return sdaResult;
                    }
                }

                sdaResult.result = true;
                return sdaResult;
            }
            catch (Exception ex)
            {
                sdaResult.result = false;
                sdaResult.resMsg = "出现异常:" + JsonConvert.SerializeObject(ex);
                return sdaResult;
            }
        }


        /// <summary>
        /// åˆ¤æ–­æ˜¯å¦æœ‰å¿ƒè·³
        /// </summary>
        /// <param name="deviceId"></param>
        /// <returns></returns>
        public SdaResEntity IsHaveHeatBeat(int deviceId)
        {
            SdaResEntity sdaResult = new SdaResEntity();
            string msg;
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                var result = Station.IsHaveHeatBeat();

                sdaResult.result = true;
                sdaResult.resData = result;
                return sdaResult;

            }
            catch (Exception ex)
            {
                msg = "验证是否有心跳出现异常:" + ex.Message;
                sdaResult.result = false;
                sdaResult.resMsg = msg;
                return sdaResult;
            }
        }


        /// <summary>
        /// 1015重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public SdaResEntity Write1015ReScan(int deviceId, bool value)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.Write1015ReScan(deviceId, value, out msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }

        /// <summary>
        /// 1019重新扫码
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public SdaResEntity Write1019ReScan(int deviceId, bool value)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.Write1019ReScan(deviceId, value, out msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }

        /// <summary>
        /// Station的任务完成ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public SdaResEntity WriteStation_FinishACK(int deviceId, bool value, int plcTaskId)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.WriteStation_FinishACK(deviceId, value, plcTaskId, out msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }


        /// <summary>
        /// å››ä¸ªå…¥åº“口扫描验证ACK赋值
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public SdaResEntity WriteScanValidateACK(bool isReset, int deviceId, string stationCode, bool value, int plcTaskId)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.WriteScanValidateACK(isReset, deviceId, stationCode, value, plcTaskId, out msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }

        /// <summary>
        /// å‘动机出库，给西港PLC发送发动机数据 ã€Editby shaocx,2023-07-23】
        /// </summary>
        /// <param name="deviceId"></param>
        /// <param name="value__Out_MaterialModel"></param>
        /// <param name="value_Out_OrderNo"></param>
        /// <param name="value_Out_SerialNumber"></param>
        /// <param name="plcTaskId"></param>
        /// <returns></returns>
        public SdaResEntity WriteStation_XigangGetDataForOut(int deviceId, string value__Out_MaterialModel,
            string value_Out_OrderNo,
            string value_Out_SerialNumber,
            int plcTaskId)
        {
            SdaResEntity _SdaResEntity = new SdaResEntity();
            try
            {
                var StationResult = Station_CacheEntity.GetDeviceObj(deviceId);
                if (!StationResult.result)
                {
                    return StationResult;
                }
                var Station = StationResult.resData as StationEntity;

                string msg = "";
                var result = Station.WriteStation_XigangGetDataForOut(deviceId, value__Out_MaterialModel, value_Out_OrderNo, value_Out_SerialNumber, plcTaskId, out msg);
                _SdaResEntity.result = result;
                _SdaResEntity.resMsg = msg;
                return _SdaResEntity;
            }
            catch (Exception ex)
            {
                _SdaResEntity.result = false;
                _SdaResEntity.resMsg = ex.Message;
                return _SdaResEntity;
            }
        }
    }
}