YG-OPP-WCS-Client/WCS.PLC/Model/Equipment/EquipmentSignal.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using WCS.Data;

namespace WCS.PLC.Model.Equipment
{
    public enum EquipmentType
    {
        srm = 1,
        conveyor = 2,
        rgv = 3
    }
    public enum DB_TypeEnum
    {
        WCS可读可写DB = 1,
        WCS只读DB = 2,
        WCS状态和故障DB = 3,
        WCS读取扫码DB = 4,
        WCS读写扩展DB1 = 5,
        WCS读写扩展DB2 = 6,
        WCS读写扩展DB3 = 7,
    }
    public class EquipmentSignal
    {
        protected string PlcName { get; set; }
        protected List<ConvDbInfo> EquDbInfoSet = new List<ConvDbInfo>();

        public byte[] DB_WCS_ReadWrite
        {
            get
            {
                return Current.PlcSet.SingleOrDefault(v => v.PLC_NAME == PlcName)
                              .WCS_DBSet
                              .SingleOrDefault(v => v.DB_NAME == EquDbInfo_ReadWrite.DBName)
                              .DB_EQUDATA.Skip(EquDbInfo_ReadWrite.DBReadIndox).Take(EquDbInfo_ReadWrite.DBReadLength).ToArray();
            }
        }
        public byte[] DB_WCS_Read
        {
            get
            {
                return Current.PlcSet.SingleOrDefault(v => v.PLC_NAME == PlcName)
                              .WCS_DBSet.SingleOrDefault(v => v.DB_NAME == EquDbInfo_Read.DBName)
                              .DB_EQUDATA.Skip(EquDbInfo_Read.DBReadIndox).Take(EquDbInfo_Read.DBReadLength).ToArray();
            }
        }
        public byte[] DB_Equ_Status
        {
            get
            {
                return Current.PlcSet.SingleOrDefault(v => v.PLC_NAME == PlcName)
                              .WCS_DBSet.SingleOrDefault(v => v.DB_NAME == EquDbInfo_Status.DBName)
                              .DB_EQUDATA.Skip(EquDbInfo_Status.DBReadIndox).Take(EquDbInfo_Status.DBReadLength).ToArray();
            }
        }
        public byte[] DB_Equ_BarCode
        {
            get
            {
                if (EquDbInfo_BarCode == null)
                {
                    return new byte[0];
                }
                else
                {
                    return Current.PlcSet.SingleOrDefault(v => v.PLC_NAME == PlcName)
                               .WCS_DBSet.SingleOrDefault(v => v.DB_NAME == EquDbInfo_BarCode.DBName)
                               .DB_EQUDATA.Skip(EquDbInfo_BarCode.DBReadIndox).Take(EquDbInfo_BarCode.DBReadLength).ToArray();
                }
            }
        }

        public ConvDbInfo EquDbInfo_ReadWrite
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS可读可写DB);
            }
        }
        public ConvDbInfo EquDbInfo_Read
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS只读DB);
            }
        }
        public ConvDbInfo EquDbInfo_Status
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS状态和故障DB);
            }
        }
        public ConvDbInfo EquDbInfo_BarCode
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS读取扫码DB);
            }
        }
        public ConvDbInfo EquDbInfo_ExtendOne
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS读写扩展DB1);
            }
        }
        public ConvDbInfo EquDbInfo_ExtendTwo
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS读写扩展DB2);
            }
        }
        public ConvDbInfo EquDbInfo_ExtendThree
        {
            get
            {
                return EquDbInfoSet.FirstOrDefault(v => v.DBType == DB_TypeEnum.WCS读写扩展DB3);
            }
        }
        public EquipmentSignal(string plcname,List<ConvDbInfo> equDBInfoSet)
        {
            PlcName = plcname;
            EquDbInfoSet = equDBInfoSet;
        }
        public dynamic QueryDB_WCS_ReadWriteSignal(string backType, int offset, int boolOffset = 0)
        {
            return QueryDB_Equ_Signal(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, backType, offset, boolOffset);
        }
        public dynamic QueryDB_WCS_ReadSignal(string backType, int offset, int boolOffset = 0)
        {
             return QueryDB_Equ_Signal(EquDbInfo_Read, DB_WCS_Read, backType, offset, boolOffset);
        }
        public dynamic QueryDB_Equ_StatusSignal(string backType, int offset, int boolOffset = 0)
        {
            return QueryDB_Equ_Signal(EquDbInfo_Status, DB_Equ_Status, backType, offset, boolOffset);
        }
        private dynamic QueryDB_Equ_Signal(ConvDbInfo equDbInfo, byte[] dB_Equ, string backType, int offset, int boolOffset = 0)
        {
            dynamic result = null;
            try
            {
                //int startindex = equDbInfo.DBReadIndox + offset;
                if (backType == "string")
                {
                    byte[] dbad = dB_Equ.Skip(offset).Take(4).ToArray();
                    result = ExtendsUtil.GetBarCodeStr(dbad).Trim();
                }
                else if (backType == "uint" || backType == "UInt32" || backType == "enumUInt32")
                {
                    result = Convert.ToUInt32(dB_Equ[offset] * 256 * 256 * 256 + dB_Equ[offset + 1] * 256 * 256 + dB_Equ[offset + 2] * 256 + dB_Equ[offset + 3]);
                }
                else if (backType == "float")
                {
                    byte[] singleBytetemp = dB_Equ.Skip(offset).Take(4).ToArray();
                    byte[] singleByte = new byte[4];
                    singleByte[0] = singleBytetemp[3];
                    singleByte[1] = singleBytetemp[2];
                    singleByte[2] = singleBytetemp[1];
                    singleByte[3] = singleBytetemp[0];

                    result = BitConverter.ToSingle(singleByte, 0);
                }
                else if (backType == "ushort" || backType == "enumUInt16" || backType == "UInt16")
                {
                    result = Convert.ToUInt16(dB_Equ[offset] * 256 + dB_Equ[offset + 1]);
                }
                else if (backType == "byte" || backType == "enumByte")
                {
                    result = Convert.ToByte(dB_Equ[offset]);
                }
                else if (backType == "bool")
                {
                    result = PlcHelper.ByteToBool(dB_Equ[offset], boolOffset);
                }
                else
                {
                    throw new Exception(string.Format("WCS读取到未知类型[{0}]无法解析,请检查输入类型是否正确", backType));
                }
            }
            catch (Exception ex)
            {
                Log4netHelper.Logger_Error.ErrorFormat(ex.ToString());
            }
            return result;
        }
        public string Query_string_DB_WCS_ReadWrite(int offset)
        {
            return Query_string(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public string Query_string_DB_WCS_Read(int offset)
        {
            return Query_string(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public string Query_string_DB_Equ_Status(int offset)
        {
            return Query_string(EquDbInfo_Status, DB_Equ_Status, offset);
        }
        public string Query_string(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;
            byte[] dbad = dB_Equ.Skip(offset).Take(4).ToArray();
            return ExtendsUtil.GetBarCodeStr(dbad).Trim();
        }
        public int Query_int_DB_WCS_ReadWrite(int offset)
        {
            return Query_int(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public uint Query_uint_DB_WCS_ReadWrite(int offset)
        {
            return Query_uint(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public uint Query_uint_DB_WCS_Read(int offset)
        {
            return Query_uint(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public int Query_int_DB_WCS_Read(int offset)
        {
            return Query_int(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public uint Query_uint_DB_Equ_Status(int offset)
        {
            return Query_uint(EquDbInfo_Status, DB_Equ_Status, offset);
        }
        public int Query_int(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;
            return Convert.ToInt32(dB_Equ[offset] * 256 * 256 * 256 + dB_Equ[offset + 1] * 256 * 256 + dB_Equ[offset + 2] * 256 + dB_Equ[offset + 3]);
        }
        public uint Query_uint(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;
            return Convert.ToUInt32(dB_Equ[offset] * 256 * 256 * 256 + dB_Equ[offset + 1] * 256 * 256 + dB_Equ[offset + 2] * 256 + dB_Equ[offset + 3]);
        }
        public float Query_float_DB_WCS_ReadWrite(int offset)
        {
            return Query_float(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public float Query_float_DB_WCS_Read(int offset)
        {
            return Query_float(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public float Query_float_DB_Equ_Status(int offset)
        {
            return Query_float(EquDbInfo_Status, DB_Equ_Status, offset);
        }
        public float Query_float(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;

            byte[] singleBytetemp = dB_Equ.Skip(offset).Take(4).ToArray();
            byte[] singleByte = new byte[4];
            singleByte[0] = singleBytetemp[3];
            singleByte[1] = singleBytetemp[2];
            singleByte[2] = singleBytetemp[1];
            singleByte[3] = singleBytetemp[0];

            return BitConverter.ToSingle(singleByte, 0);
        }
        public ushort Query_ushort_DB_WCS_ReadWrite(int offset)
        {
            return Query_ushort(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public ushort Query_ushort_DB_WCS_Read(int offset)
        {
            return Query_ushort(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public ushort Query_ushort_DB_Equ_Status(int offset)
        {
            return Query_ushort(EquDbInfo_Status, DB_Equ_Status, offset);
        }
        public ushort Query_ushort(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            try
            {
                return Convert.ToUInt16(dB_Equ[offset] * 256 + dB_Equ[offset + 1]);
            }
            catch (Exception ex)
            {
                return 0;
            }
            //int startindex = equDbInfo.DBReadIndox + offset;
           
        }
        public byte Query_byte_DB_WCS_ReadWrite(int offset)
        {
            return Query_byte(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset);
        }
        public byte Query_byte_DB_WCS_Read(int offset)
        {
            return Query_byte(EquDbInfo_Read, DB_WCS_Read, offset);
        }
        public byte Query_byte_DB_Equ_Status(int offset)
        {
            return Query_byte(EquDbInfo_Status, DB_Equ_Status, offset);
        }
        public byte Query_byte(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;
            return Convert.ToByte(dB_Equ[offset]);
        }
        public bool Query_bool_DB_WCS_ReadWrite(int offset, int boolOffset = 0)
        {
            return Query_bool(EquDbInfo_ReadWrite, DB_WCS_ReadWrite, offset, boolOffset);
        }
        public bool Query_bool_DB_WCS_Read(int offset, int boolOffset = 0)
        {
            return Query_bool(EquDbInfo_Read, DB_WCS_Read, offset, boolOffset);
        }
        public bool Query_bool_DB_Equ_Status(int offset, int boolOffset = 0)
        {
            return Query_bool(EquDbInfo_Status, DB_Equ_Status, offset, boolOffset);
        }
        public bool Query_bool(ConvDbInfo equDbInfo, byte[] dB_Equ, int offset, int boolOffset = 0)
        {
            //int startindex = equDbInfo.DBReadIndox + offset;
            return PlcHelper.ByteToBool(dB_Equ[offset], boolOffset);
        }
        public List<string> Query_BarCode()
        {
            List<string> barCodeSet = new List<string>();
            if (EquDbInfo_BarCode != null)
            {
                foreach (var item in EquDbInfo_BarCode.ScannSet)
                {
                    //byte[] dbsann = DB_Equ_BarCode.Skip(item.SCANN_STARTADDRESS).Take(item.SCANN_LENGTH).ToArray();
                    string barcode = ExtendsUtil.GetBarCodeStr(DB_Equ_BarCode).Trim();
                    barCodeSet.Add(barcode);
                }
            }
            return barCodeSet;
        }
    }
    public class ConvDbInfo
    {
        public int DBName { get; set; }
        public DB_TypeEnum DBType { get; set; }
        public int DBReadIndox { get; set; }
        public int DBReadLength { get; set; }

        public List<WCS_SCANN> ScannSet = new List<WCS_SCANN>();
    }
}