20241228

util.cs

@@ -16,13 +16,15 @@ using System.Net.NetworkInformation;
 using System.Net;
 using System.Management;
 using System.IO.Ports;
+using System.IO;
+using System.Security.Cryptography;
+using System.Windows.Forms.Design;
 
 namespace UTIL
 {
+    #region Методы доступа к атрибутам сборки
     public static class ASMBL
     {
-        #region Методы доступа к атрибутам сборки
-
         public static string AssemblyTitle
         {
             get
@@ -39,7 +41,6 @@ namespace UTIL
                 return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase);
             }
         }
-
         public static string AssemblyVersion
         {
             get
@@ -47,7 +48,6 @@ namespace UTIL
                 return Assembly.GetExecutingAssembly().GetName().Version.ToString();
             }
         }
-
         public static string AssemblyDescription
         {
             get
@@ -60,7 +60,6 @@ namespace UTIL
                 return ((AssemblyDescriptionAttribute)attributes[0]).Description;
             }
         }
-
         public static string AssemblyProduct
         {
             get
@@ -77,7 +76,6 @@ namespace UTIL
 #endif
             }
         }
-
         public static string AssemblyCopyright
         {
             get
@@ -90,7 +88,6 @@ namespace UTIL
                 return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
             }
         }
-
         public static string AssemblyCompany
         {
             get
@@ -189,9 +186,10 @@ namespace UTIL
                 return s;
             }
         }
-        #endregion
     }
+    #endregion
 
+    #region Работа с INI файлами
     public class IniFile
     {
         [DllImport("kernel32.dll")]
@@ -248,10 +246,11 @@ namespace UTIL
             WritePrivateProfileString(section, key, val.ToString(), IniFileName);
         }
     }
+    #endregion
 
+    #region Загрузка/выгрузка данных в структуру
     public static class S2B
     {
-        #region Загрузка/выгрузка данных в структуру
         //public static T BuffToStruct<T>(byte[] arr)
         //{
         //    GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned);
@@ -294,9 +293,10 @@ namespace UTIL
             gch.Free(); // снять фиксацию
             return arr;
         }
-        #endregion
     }
+    #endregion
 
+    #region Расширенные методы RichTextBox
     public static class RichTextBoxExtensions
     {
         public static void AppendText(this RichTextBox box, string text, Color color)
@@ -352,7 +352,9 @@ namespace UTIL
             }
         }
     }
+    #endregion
 
+    #region фильтр Калмана
     public class GKalman
     {
         double _err_measure = 0.0F;
@@ -395,7 +397,9 @@ namespace UTIL
             return (double)_current_estimate;
         }
     }
+    #endregion
 
+    #region unsafe методы работы с изображением
     public unsafe class UnsafeBitmap
     {
         Bitmap bitmap;
@@ -481,6 +485,9 @@ namespace UTIL
         public byte green;
         public byte red;
     }
+    #endregion
+
+    #region мелкие функции
     public static class Util
     {
         public static List<String> getportnames()
@@ -560,6 +567,16 @@ namespace UTIL
                 return dmax;
             return dval;
         }
+
+        //public T minmax<T>(T min, T max, T val) where T : IComparable<T>
+        //{
+        //    if (val.CompareTo(min) <= 0)
+        //        return min;
+        //    if (val.CompareTo(max) > 0)
+        //        return max;
+        //    return val;
+        //}
+
         public struct Hex<T>
         {
             private T _Value;
@@ -699,29 +716,45 @@ namespace UTIL
                     return num.ToString();
             }
         }
+
         #region создание нового имени файла из оригинального открытого с учетом дублей
-        //public static String NewFileName(String fullfilename, String newextention)
+        public static void NewFileName(Byte[] data, String filename, char delim = '_')
-        //{
+        {
-        //	if (!iofile.Exists(fullfilename.Replace(".bmp", "_00" + newextention)))
+            SaveFileDialog sfd = new SaveFileDialog();
-        //		return fullfilename.Replace(".bmp", "_00" + newextention);
+            sfd.OverwritePrompt = false;
-        //	DirectoryInfo dir = new DirectoryInfo(iopath.GetDirectoryName(fullfilename));
+            sfd.FileName = filename;
-        //	String lastname;
+            if (sfd.ShowDialog() != DialogResult.OK)
-        //	int lastnum = 0;
+                return;
-        //	String sss = "";
+
-        //	foreach (FileInfo item in dir.GetFiles("*" + newextention))
+            if (!File.Exists(sfd.FileName))
-        //	{
+                filename = sfd.FileName;
-        //		//MessageBox.Show(item.FullName);
+
-        //		if (item.FullName.StartsWith(fullfilename.Replace(".bmp", "")))
+            String fnamewoext = Path.GetFileNameWithoutExtension(filename);
-        //		{
+            String fileext = Path.GetExtension(filename);
-        //			lastname = item.FullName;
+            String dirname = Path.GetDirectoryName(filename);
-        //			lastnum = Convert.ToInt32(lastname.Replace(fullfilename.Replace(".bmp", ""), "").Replace(newextention, "").Remove(0, 1));
+            String fname = fnamewoext.Split(delim)[0];
-        //			sss += lastname + "\r\n";
+            var directory = new DirectoryInfo(dirname == "" ? Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath):dirname);
-        //		}
+            FileInfo[] files = directory.GetFiles(fname + delim.ToString() + "???" + fileext);
-        //	}
+            String nextfn = "";
-        //	//MessageBox.Show(sss + "\r\n" + (lastnum + 1).ToString());
+            if (files.Length > 0)
-        //	return fullfilename.Replace(".bmp", "") + "_" + (lastnum + 1).ToString("D2") + newextention;
+            {
-        //}
+                String tmp = files[files.Length - 1].FullName.Replace(fileext, "");
+                Int32 lastnum = Int32.Parse(tmp.Split(delim)[tmp.Split(delim).Length - 1]);
+                String nextnum = (lastnum + 1).ToString("D3");
+                String lastfn = files[files.Length - 1].FullName.Replace(fileext, "").Replace(delim + lastnum.ToString("D3"),"");
+                nextfn = lastfn + delim.ToString() + nextnum + fileext;
+            }
+            else
+            {
+                nextfn = fname + delim.ToString() + "000" + fileext;
+            }
+
+            Console.WriteLine($"{nextfn}");
+            File.WriteAllBytes(nextfn, data);
+            MessageBox.Show($"Файл сохранен под именем:{Environment.NewLine}{nextfn}");
+        }
         #endregion
+
         #region Поиск последовательного порта по пид и вид
         public static (String COM, String PID, String VID) SearchSerial(String pid, String vid)
         {
@@ -746,7 +779,486 @@ namespace UTIL
             return ("", "", "");
         }
         #endregion
+		
+        public static Byte[] auchCRCHi = new Byte[]
+        {
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+            0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40
+        };
+        public static Byte[] auchCRCLo = new Byte[]
+        {
+            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
+            0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
+            0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
+            0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
+            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
+            0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
+            0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
+            0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
+            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
+            0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
+            0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
+            0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
+            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
+            0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
+            0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
+            0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
+            0x40
+        };
+		
+        public static UInt16 CRC16(ref Byte[] d, UInt16 len)
+        {
+            Byte crc_hi = 0xFF;
+            Byte crc_lo = 0xFF;
+            Byte j = 0;
+            do
+            {
+                Byte i = (Byte)(crc_hi ^ d[j++]);
+                crc_hi = (Byte)(crc_lo ^ (Byte)auchCRCHi[i]);
+                crc_lo = (Byte)(auchCRCLo[i]);
+            } while (--len != 0);
+
+            return (UInt16)((crc_hi << 8) | crc_lo);
+        }
+
+        public static Byte Min(Byte[] arr)
+        {
+            switch (arr.Length)
+            {
+                case 0: throw new InvalidOperationException();
+                case 1: return arr[0];
+                case 2: return Math.Min(arr[0], arr[1]);
+                default:
+                    Byte min = arr[0];
+                    for (int i = 1; i < arr.Length; i++)
+                    {
+                        if (arr[i] < min) min = arr[i];
+                    }
+                    return min;
+            }
+        }
+    }
+    #endregion
+
+    #region CRC8
+    /*
+        public static class Crc8
+        {
+            private static readonly byte[] Table = new byte[256];
+            private const byte Poly = 0xd5;
+
+            public static byte ComputeChecksum(params byte[] bytes)
+            {
+                byte crc = 0;
+                if (bytes is { Length: > 0 }) crc = bytes.Aggregate(crc, (current, b) => Table[current ^ b]);
+                return crc;
+            }
+
+            static Crc8()
+            {
+                for (var i = 0; i < 256; ++i)
+                {
+                    var temp = i;
+                    for (var j = 0; j < 8; ++j)
+                        if ((temp & 0x80) != 0)
+                            temp = (temp << 1) ^ Poly;
+                        else
+                            temp <<= 1;
+                    Table[i] = (byte)temp;
+                }
+            }
+        }
+    */
+    public class CRC8_2
+    {
+        //CRC8Calc crc_dallas = new CRC8Calc(CRC8_POLY.CRC8_DALLAS_MAXIM);
+        //checksum = crc_dallas.Checksum(testVal);
+        //CRC8Calc crc = new CRC8Calc(CRC8_POLY.CRC8_CCITT);
+        //checksum = crc.Checksum(testVal);
+
+        public enum CRC8_POLY
+        {
+            CRC8 = 0xd5,
+            CRC8_CCITT = 0x07,
+            CRC8_DALLAS_MAXIM = 0x31,
+            CRC8_SAE_J1850 = 0x1D,
+            CRC_8_WCDMA = 0x9b,
+        };
+        private byte[] table = new byte[256];
+
+        public byte Checksum(params byte[] val)
+        {
+            if (val == null)
+                throw new ArgumentNullException("val");
+            byte c = 0;
+            foreach (byte b in val)
+                c = table[c ^ b];
+            return c;
+        }
+
+        public byte[] Table
+        {
+            get
+            {
+                return this.table;
+            }
+            set
+            {
+                this.table = value;
+            }
+        }
+
+        public byte[] GenerateTable(CRC8_POLY polynomial)
+        {
+            byte[] csTable = new byte[256];
+            for (int i = 0; i < 256; ++i)
+            {
+                int curr = i;
+                for (int j = 0; j < 8; ++j)
+                {
+                    if ((curr & 0x80) != 0)
+                        curr = (curr << 1) ^ (int)polynomial;
+                    else
+                        curr <<= 1;
+                }
+                csTable[i] = (byte)curr;
+            }
+            return csTable;
+        }
+
+        public CRC8_2(CRC8_POLY polynomial)
+        {
+            this.table = this.GenerateTable(polynomial);
+        }
+    }
+
+    public static class CRC8_3
+    {
+        static byte[] CRC8_TABLE = new byte[]{
+        0, 94, 188, 226, 97, 63, 221, 131, 194, 156, 126, 32, 163, 253, 31, 65,
+        157, 195, 33, 127, 252, 162, 64, 30, 95, 1, 227, 189, 62, 96, 130, 220,
+        35, 125, 159, 193, 66, 28, 254, 160, 225, 191, 93, 3, 128, 222, 60, 98,
+        190, 224, 2, 92, 223, 129, 99, 61, 124, 34, 192, 158, 29, 67, 161, 255,
+        70, 24, 250, 164, 39, 121, 155, 197, 132, 218, 56, 102, 229, 187, 89, 7,
+        219, 133, 103, 57, 186, 228, 6, 88, 25, 71, 165, 251, 120, 38, 196, 154,
+        101, 59, 217, 135, 4, 90, 184, 230, 167, 249, 27, 69, 198, 152, 122, 36,
+        248, 166, 68, 26, 153, 199, 37, 123, 58, 100, 134, 216, 91, 5, 231, 185,
+        140, 210, 48, 110, 237, 179, 81, 15, 78, 16, 242, 172, 47, 113, 147, 205,
+        17, 79, 173, 243, 112, 46, 204, 146, 211, 141, 111, 49, 178, 236, 14, 80,
+        175, 241, 19, 77, 206, 144, 114, 44, 109, 51, 209, 143, 12, 82, 176, 238,
+        50, 108, 142, 208, 83, 13, 239, 177, 240, 174, 76, 18, 145, 207, 45, 115,
+        202, 148, 118, 40, 171, 245, 23, 73, 8, 86, 180, 234, 105, 55, 213, 139,
+        87, 9, 235, 181, 54, 104, 138, 212, 149, 203, 41, 119, 244, 170, 72, 22,
+        233, 183, 85, 11, 136, 214, 52, 106, 43, 117, 151, 201, 74, 20, 246, 168,
+        116, 42, 200, 150, 21, 75, 169, 247, 182, 232, 10, 84, 215, 137, 107, 53
+    };
+
+        public static byte Calculate(byte[] data, byte init = 0)
+        {
+            byte result = init;
+            for (var i = 0; i < data.Length; i++)
+            {
+                result = CRC8_TABLE[result ^ data[i]];
+            }
+            return result;
+        }
+    }
+    #endregion
+
+    #region CRC16
+    public static class Crc16_1
+    {
+        static Byte[] auchCRCHi = new Byte[]
+        {
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
+            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
+            0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
+            0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
+            0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
+            0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
+            0x40
+        };
+        static Byte[] auchCRCLo = new Byte[]
+        {
+            0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
+            0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
+            0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
+            0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
+            0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
+            0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
+            0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
+            0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
+            0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
+            0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
+            0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
+            0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
+            0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
+            0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
+            0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
+            0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
+            0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
+            0x40
+        };
+
+        public static UInt16 CRC16(ref Byte[] d, UInt16 len)
+        {
+            Byte crc_hi = 0xFF;
+            Byte crc_lo = 0xFF;
+            Byte j = 0;
+            do
+            {
+                Byte i = (Byte)(crc_hi ^ d[j++]);
+                crc_hi = (Byte)(crc_lo ^ (Byte)auchCRCHi[i]);
+                crc_lo = (Byte)(auchCRCLo[i]);
+            } while (--len != 0);
+            return (UInt16)((crc_hi << 8) | crc_lo);
+        }
+    }
+    #endregion
+
+    #region CRC32
+    public static class Crc32_1
+    {
+        private static readonly uint[] crcTable = new uint[256];
+
+        static Crc32_1()
+        {
+            const uint polynomial = 0xDEADDEAD;
+            for (uint i = 0; i < 256; i++)
+            {
+                uint crc = i;
+                for (int j = 0; j < 8; j++)
+                {
+                    if ((crc & 1) == 1)
+                    {
+                        crc = (crc >> 1) ^ polynomial;
+                    }
+                    else
+                    {
+                        crc >>= 1;
+                    }
+                }
+                crcTable[i] = crc;
+            }
+        }
+        public static uint Calculate(byte[] data)
+        {
+            uint crc = 0xFFFFFFFF;
+
+            foreach (byte b in data)
+            {
+                byte tableIndex = (byte)(((crc) & 0xFF) ^ b);
+                crc = crcTable[tableIndex] ^ (crc >> 8);
+            }
+
+            return ~crc;
+        }
+    }
+    public class Crc32_2 : HashAlgorithm
+    {
+        public const UInt32 DefaultPolynomial = 0xedb88320;
+        public const UInt32 DefaultSeed = 0xffffffff;
+
+        private UInt32 hash;
+        private UInt32 seed;
+        private UInt32[] table;
+        private static UInt32[] defaultTable;
+
+        public Crc32_2()
+        {
+            table = InitializeTable(DefaultPolynomial);
+            seed = DefaultSeed;
+            Initialize();
+        }
+
+        public Crc32_2(UInt32 polynomial, UInt32 seed)
+        {
+            table = InitializeTable(polynomial);
+            this.seed = seed;
+            Initialize();
+        }
+
+        public override void Initialize()
+        {
+            hash = seed;
+        }
+
+        protected override void HashCore(byte[] buffer, int start, int length)
+        {
+            hash = CalculateHash(table, hash, buffer, start, length);
+        }
+
+        protected override byte[] HashFinal()
+        {
+            byte[] hashBuffer = UInt32ToBigEndianBytes(~hash);
+            this.HashValue = hashBuffer;
+            return hashBuffer;
         }
+
+        public override int HashSize
+        {
+            get { return 32; }
+        }
+
+        public static UInt32 Compute(byte[] buffer)
+        {
+            return ~CalculateHash(InitializeTable(DefaultPolynomial), DefaultSeed, buffer, 0, buffer.Length);
+        }
+
+        public static UInt32 Compute(UInt32 seed, byte[] buffer)
+        {
+            return ~CalculateHash(InitializeTable(DefaultPolynomial), seed, buffer, 0, buffer.Length);
+        }
+
+        public static UInt32 Compute(UInt32 polynomial, UInt32 seed, byte[] buffer)
+        {
+            return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
+        }
+
+        private static UInt32[] InitializeTable(UInt32 polynomial)
+        {
+            if (polynomial == DefaultPolynomial && defaultTable != null)
+                return defaultTable;
+
+            UInt32[] createTable = new UInt32[256];
+            for (int i = 0; i < 256; i++)
+            {
+                UInt32 entry = (UInt32)i;
+                for (int j = 0; j < 8; j++)
+                    if ((entry & 1) == 1)
+                        entry = (entry >> 1) ^ polynomial;
+                    else
+                        entry = entry >> 1;
+                createTable[i] = entry;
+            }
+
+            if (polynomial == DefaultPolynomial)
+                defaultTable = createTable;
+
+            return createTable;
+        }
+
+        private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, byte[] buffer, int start, int size)
+        {
+            UInt32 crc = seed;
+            for (int i = start; i < size; i++)
+                unchecked
+                {
+                    crc = (crc >> 8) ^ table[buffer[i] ^ crc & 0xff];
+                }
+            return crc;
+        }
+
+        private byte[] UInt32ToBigEndianBytes(UInt32 x)
+        {
+            return new byte[] {
+            (byte)((x >> 24) & 0xff),
+            (byte)((x >> 16) & 0xff),
+            (byte)((x >> 8) & 0xff),
+            (byte)(x & 0xff)
+        };
+        }
+
+        public string Get(string FilePath)
+        {
+            Crc32_2 crc32 = new Crc32_2();
+            String hash = String.Empty;
+
+            using (FileStream fs = File.Open(FilePath, FileMode.Open))
+                foreach (byte b in crc32.ComputeHash(fs)) hash += b.ToString("x2").ToLower();
+
+            return hash;
+        }
+    }
+    public class Crc32_3
+    {
+        private readonly uint[] _table;
+        private const uint Poly = 0xedb88320;
+
+        private uint ComputeChecksum(IEnumerable<byte> bytes)
+        {
+            var crc = 0xffffffff;
+            foreach (var t in bytes)
+            {
+                var index = (byte)((crc & 0xff) ^ t);
+                crc = (crc >> 8) ^ _table[index];
+            }
+            return ~crc;
+        }
+
+        public IEnumerable<byte> ComputeChecksumBytes(IEnumerable<byte> bytes)
+        {
+            return BitConverter.GetBytes(ComputeChecksum(bytes));
+        }
+
+        public Crc32_3()
+        {
+            _table = new uint[256];
+            for (uint i = 0; i < _table.Length; ++i)
+            {
+                var temp = i;
+                for (var j = 8; j > 0; --j)
+                    if ((temp & 1) == 1)
+                        temp = (temp >> 1) ^ Poly;
+                    else
+                        temp >>= 1;
+                _table[i] = temp;
+            }
+        }
+    }
+    public class Crc32_4
+    {
+        byte[] GetCRC32(IEnumerable<byte> bytes)
+        {
+            var crcTable = new uint[256];
+            uint crc;
+
+            for (uint i = 0; i < 256; i++)
+            {
+                crc = i;
+                for (uint j = 0; j < 8; j++)
+                    crc = (crc & 1) != 0 ? (crc >> 1) ^ 0xEDB88320 : crc >> 1;
+
+                crcTable[i] = crc;
+            }
+
+            crc = bytes.Aggregate(0xFFFFFFFF, (current, s) => crcTable[(current ^ s) & 0xFF] ^ (current >> 8));
+
+            crc ^= 0xFFFFFFFF;
+            return BitConverter.GetBytes(crc);
+        }
+    }
+    #endregion
+
+    #region Циклический буфер
     public class CircularBuffer<T>
     {
         T[] _buffer;
@@ -870,6 +1382,9 @@ namespace UTIL
                 _length++;
         }
     }
+    #endregion
+
+    #region Медианный фильтр
     public class GMedian
     {
         UInt16[] bufUI16;
@@ -1019,6 +1534,9 @@ namespace UTIL
                 }
         */
     }
+    #endregion
+
+    #region Работа с сетевыми адаптерами
     public class SetNet
     {
         public void setIP(string caption, string ipaddress, Boolean dhcp)
@@ -1133,6 +1651,9 @@ namespace UTIL
             return adapters;
         }
     }
+    #endregion
+
+    #region Медианный фильтр 2
     public class GMedian3
     {
         public UInt16 filtered(UInt16 value)
@@ -1186,6 +1707,9 @@ namespace UTIL
         Single[] buff = new Single[3];
         Byte _counter = 0;
     };
+    #endregion
+
+    #region Параметры командной строки
     public class ParParse
     {
         private List<(bool, String, String, bool, String)> Pars = new List<(bool, string, string, bool, string)>();
@@ -1242,5 +1766,251 @@ namespace UTIL
             return rez;
         }
     }
+    #endregion
+
+    #region Компоненты меню
+    [System.ComponentModel.DesignerCategory("code")]
+    [ToolStripItemDesignerAvailability(
+        ToolStripItemDesignerAvailability.ContextMenuStrip |
+        ToolStripItemDesignerAvailability.MenuStrip |
+        ToolStripItemDesignerAvailability.StatusStrip |
+        ToolStripItemDesignerAvailability.ToolStrip)]
+    public partial class ToolStripTrackBar : ToolStripControlHost
+    {
+        public ToolStripTrackBar() : base(CreateControlInstance())
+        {
+        }
+        /// <summary>
+        /// Create a strongly typed property called TrackBar - handy to prevent casting everywhere.
+        /// </summary>
+        public TrackBar TrackBar
+        {
+            get
+            {
+                return Control as TrackBar;
+            }
+        }
+        /// <summary>
+        /// Create the actual control, note this is static so it can be called from the
+        /// constructor.
+        ///
+        /// </summary>
+        /// <returns></returns>
+        private static Control CreateControlInstance()
+        {
+            TrackBar t = new TrackBar();
+            t.AutoSize = false;
+            // Add other initialization code here.
+            return t;
+        }
+        [DefaultValue(0)]
+        public int Value
+        {
+            get { return TrackBar.Value; }
+            set { TrackBar.Value = value; }
+        }
+        /// <summary>
+        /// Attach to events we want to re-wrap
+        /// </summary>
+        /// <param name="control"></param>
+        [DefaultValue(0)]
+        public int Minimum
+        {
+            get { return TrackBar.Minimum; }
+            set { TrackBar.Minimum = value; }
+        }
+        [DefaultValue(100)]
+        public int Maximum
+        {
+            get { return TrackBar.Maximum; }
+            set { TrackBar.Maximum = value; }
+        }
+        [DefaultValue(10)]
+        public int TickFrequency
+        {
+            get { return TrackBar.TickFrequency; }
+            set { TrackBar.TickFrequency = value; }
+        }
+        public TickStyle TickStyle
+        {
+            get { return TrackBar.TickStyle; }
+            set { TrackBar.TickStyle = value; }
+        }
+        protected override void OnSubscribeControlEvents(Control control)
+        {
+            base.OnSubscribeControlEvents(control);
+            TrackBar trackBar = control as TrackBar;
+            trackBar.ValueChanged += new EventHandler(trackBar_ValueChanged);
+        }
+        /// <summary>
+        /// Detach from events.
+        /// </summary>
+        /// <param name="control"></param>
+        protected override void OnUnsubscribeControlEvents(Control control)
+        {
+            base.OnUnsubscribeControlEvents(control);
+            TrackBar trackBar = control as TrackBar;
+            trackBar.ValueChanged -= new EventHandler(trackBar_ValueChanged);
+        }
+        /// <summary>
+        /// Routing for event
+        /// TrackBar.ValueChanged -> ToolStripTrackBar.ValueChanged
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void trackBar_ValueChanged(object sender, EventArgs e)
+        {
+            // when the trackbar value changes, fire an event.
+            if (this.ValueChanged != null)
+            {
+                ValueChanged(sender, e);
+            }
+        }
+        // add an event that is subscribable from the designer.
+        public event EventHandler ValueChanged;
+        // set other defaults that are interesting
+        protected override Size DefaultSize
+        {
+            get
+            {
+                return new Size(200, 16);
+            }
+        }
+    }
+
+    [System.ComponentModel.DesignerCategory("code")]
+    [ToolStripItemDesignerAvailability(
+        ToolStripItemDesignerAvailability.ContextMenuStrip |
+        ToolStripItemDesignerAvailability.MenuStrip |
+        ToolStripItemDesignerAvailability.StatusStrip |
+        ToolStripItemDesignerAvailability.ToolStrip)]
+    public partial class ToolStripNumericUpDown : ToolStripControlHost
+    {
+        public ToolStripNumericUpDown() : base(CreateControlInstance())
+        {
+        }
+        /// <summary>
+        /// Create a strongly typed property called TrackBar - handy to prevent casting everywhere.
+        /// </summary>
+        public NumericUpDown NumericUpDown
+        {
+            get
+            {
+                return Control as NumericUpDown;
+            }
+        }
+        /// <summary>
+        /// Create the actual control, note this is static so it can be called from the
+        /// constructor.
+        ///
+        /// </summary>
+        /// <returns></returns>
+        private static Control CreateControlInstance()
+        {
+            NumericUpDown t = new NumericUpDown();
+            t.AutoSize = false;
+            // Add other initialization code here.
+            return t;
+        }
+        [DefaultValue(0)]
+        public int Value
+        {
+            get { return (int)NumericUpDown.Value; }
+            set { NumericUpDown.Value = value; }
+        }
+        /// <summary>
+        /// Attach to events we want to re-wrap
+        /// </summary>
+        /// <param name="control"></param>
+        [DefaultValue(0)]
+        public int Minimum
+        {
+            get { return (int)NumericUpDown.Minimum; }
+            set { NumericUpDown.Minimum = value; }
+        }
+        [DefaultValue(100)]
+        public int Maximum
+        {
+            get { return (int)NumericUpDown.Maximum; }
+            set { NumericUpDown.Maximum = value; }
+        }
+        [DefaultValue(10)]
+        public int Increment
+        {
+            get { return (int)NumericUpDown.Increment; }
+            set { NumericUpDown.Increment = value; }
+        }
+        protected override void OnSubscribeControlEvents(Control control)
+        {
+            base.OnSubscribeControlEvents(control);
+            NumericUpDown t = control as NumericUpDown;
+            t.ValueChanged += new EventHandler(updown_ValueChanged);
+        }
+        /// <summary>
+        /// Detach from events.
+        /// </summary>
+        /// <param name="control"></param>
+        protected override void OnUnsubscribeControlEvents(Control control)
+        {
+            base.OnUnsubscribeControlEvents(control);
+            NumericUpDown t = control as NumericUpDown;
+            t.ValueChanged -= new EventHandler(updown_ValueChanged);
+        }
+        /// <summary>
+        /// Routing for event
+        /// TrackBar.ValueChanged -> ToolStripTrackBar.ValueChanged
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void updown_ValueChanged(object sender, EventArgs e)
+        {
+            // when the trackbar value changes, fire an event.
+            if (this.ValueChanged != null)
+            {
+                ValueChanged(sender, e);
+            }
+        }
+        // add an event that is subscribable from the designer.
+        public event EventHandler ValueChanged;
+        // set other defaults that are interesting
+        protected override Size DefaultSize
+        {
+            get
+            {
+                return new Size(200, 16);
+            }
+        }
+    }
+
+    [System.ComponentModel.DesignerCategory("code")]
+    [ToolStripItemDesignerAvailability(
+        ToolStripItemDesignerAvailability.ContextMenuStrip |
+        ToolStripItemDesignerAvailability.MenuStrip |
+        ToolStripItemDesignerAvailability.StatusStrip |
+        ToolStripItemDesignerAvailability.ToolStrip)]
+    public partial class ToolStripLabel : ToolStripControlHost
+    {
+        public ToolStripLabel() : base(CreateControlInstance())
+        {
+        }
+        public Label Label
+        {
+            get
+            {
+                return Control as Label;
+            }
+        }
+        private static Control CreateControlInstance()
+        {
+            Label t = new Label();
+            t.AutoSize = false;
+            t.Height = 15;
+            //            t.Width = 120;
+            t.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
+            // Add other initialization code here.
+            return t;
+        }
+    }
+    #endregion
 
 }