HighWayAssemble/Mesnac.DeviceAdapter.RFly_I160/StringChange.cs

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

namespace Mesnac.DeviceAdapter.RFly_I160
{
    public static class StringChange
    {
        //CRC异或校验
        public static byte CalculateVerify(byte[] pMessage, int iLength)
        {
            UInt16 i;
            byte iVerify = 0;

            iVerify = pMessage[0];
            for (i = 1; i < iLength; i++)
            {
                iVerify = (byte)(iVerify ^ pMessage[i]);
            }
            return iVerify;
        }
        public static byte[] Swap16Bytes(byte[] OldU16)
        {
            byte[] ReturnBytes = new byte[2];
            ReturnBytes[1] = OldU16[0];
            ReturnBytes[0] = OldU16[1];
            return ReturnBytes;
        }

        public static bool CompareBytes(byte[] byteA, byte[] byteB, int iLen)
        {
            for (int i = 0; i < iLen; i++)
            {
                if (byteA[i] != byteB[i])
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 将byte数组转换成十六进制字符串 //e.g. { 0x01, 0x01} ---> " 01 01"
        /// </summary>
        /// <param name="bytes">byte数组</param>
        /// <param name="iLen">数组长度</param>
        /// <returns>十六进制字符串</returns>
        public static string bytesToHexStr(byte[] bytes , int iLen)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < iLen; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }

        public static byte[] HexStrTorbytes(string strHex)//e.g. " 01 01" ---> { 0x01, 0x01}
        {
            strHex = strHex.Replace(" ", "");
            if ((strHex.Length % 2) != 0)
                strHex += " ";
            byte[] returnBytes = new byte[strHex.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(strHex.Substring(i * 2, 2), 16);
            return returnBytes;
        }
        public static string StringToHexString(string s, Encoding encode)
        {
            byte[] b = encode.GetBytes(s);          //按照指定编码将string编程字节数组
            string result = string.Empty;
            for (int i = 0; i < b.Length; i++)      //逐字节变为16进制字符，以%隔开
            {
                result += "%" + Convert.ToString(b[i], 16);
            }
            return result;
        }
        public static string HexStringToString(string hs, Encoding encode)
        {
            //以%分割字符串，并去掉空字符
            string[] chars = hs.Split(new char[] { '%' }, StringSplitOptions.RemoveEmptyEntries);
            byte[] b = new byte[chars.Length];
            //逐个字符变为16进制字节数据
            for (int i = 0; i < chars.Length; i++)
            {
                b[i] = Convert.ToByte(chars[i], 16);
            }
            //按照指定编码将字节数组变为字符串
            return encode.GetString(b);
        }

        public static short SwapInt16(this short n)
        {
            return (short)(((n & 0xff) << 8) | ((n >> 8) & 0xff));
        }

        public static ushort SwapUInt16(this ushort n)
        {
            return (ushort)(((n & 0xff) << 8) | ((n >> 8) & 0xff));
        }

        public static int SwapInt32(this int n)
        {
            return (int)(((SwapInt16((short)n) & 0xffff) << 0x10) |
                          (SwapInt16((short)(n >> 0x10)) & 0xffff));
        }

        public static uint SwapUInt32(this uint n)
        {
            return (uint)(((SwapUInt16((ushort)n) & 0xffff) << 0x10) |
                           (SwapUInt16((ushort)(n >> 0x10)) & 0xffff));
        }

        public static long SwapInt64(this long n)
        {
            return (long)(((SwapInt32((int)n) & 0xffffffffL) << 0x20) |
                           (SwapInt32((int)(n >> 0x20)) & 0xffffffffL));
        }

        public static ulong SwapUInt64(this ulong n)
        {
            return (ulong)(((SwapUInt32((uint)n) & 0xffffffffL) << 0x20) |
                            (SwapUInt32((uint)(n >> 0x20)) & 0xffffffffL));
        }
        public class IOInfo
        {
            public int id;
            public byte[] state;
            public DateTime time;
        }
        public class MethodFilterData
        {
            private static List<IOInfo> IOInfolist = new List<IOInfo>();
            /// <summary>
            /// 消除抖动，删除短暂时间内的
            /// </summary>
            /// <returns></returns>
            public static bool EliminatingJitter(int id, byte[] data)
            {
                var index = IOInfolist.FindIndex((x) => { return x.id == id; });
                if (index == -1 || Array.Equals(IOInfolist[index].state, data))
                {
                    IOInfolist.Add(new IOInfo
                    {
                        id = id,
                        state = data,
                        time = DateTime.Now
                    });
                }
                else
                {
                    TimeSpan ts1 = new TimeSpan(IOInfolist[index].time.Ticks);
                    TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
                    TimeSpan ts3 = ts2.Subtract(ts1); //ts2-ts1
                    double sumSeconds = Convert.ToDouble(ts3.TotalSeconds.ToString()); //得到相差秒数

                    if (sumSeconds < 5)
                    {
                        return true;
                    }
                    else
                    {
                        IOInfolist[index] = new IOInfo
                        {
                            id = id,
                            state = data,
                            time = DateTime.Now
                        };
                    }
                }
                return false;
            }
            /// <summary>
            /// 屏蔽重复条码
            /// </summary>
            /// <param name="id">传感器编号</param>
            /// <param name="data"></param>
            /// <returns></returns>
            public static bool IsRepeat(int id, byte[] data)
            {
                var index = IOInfolist.FindIndex((x) => { return x.id == id; });
                if (index == -1)
                {
                    IOInfolist.Add(new IOInfo
                    {
                        id = id,
                        state = data,
                        time = DateTime.Now
                    });
                    return false;
                }
                if (string.Equals(bytesToHexStr(IOInfolist[index].state, IOInfolist[index].state.Length), bytesToHexStr(data, data.Length)))
                {
                    IOInfolist[index].time = DateTime.Now;
                    return true;
                }
                else
                {
                    IOInfolist[index].state = data;
                    return false;
                }
            }
        }
        public static int HexStringToNegative(string strNumber)
        {

            int iNegate = 0;
            int iNumber = Convert.ToInt32(strNumber, 16);
            if (iNumber > 127)
            {
                int iComplement = iNumber - 1;
                string strNegate = string.Empty;
                char[] binchar = Convert.ToString(iComplement, 2).PadLeft(8, '0').ToArray();
                foreach (char ch in binchar)
                {
                    if (Convert.ToInt32(ch) == 48)
                    {
                        strNegate += "1";
                    }
                    else
                    {
                        strNegate += "0";
                    }
                }
                iNegate = -Convert.ToInt32(strNegate, 2);
            }
            return iNegate;
        }
    }

}