From 8deea834eb6edf4d76fe9c25444ca67f5febf454 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=B5=D0=BD=D0=B8=D1=81=20=D0=9A=D1=83=D0=B7=D0=BD?= =?UTF-8?q?=D0=B5=D1=86=D0=BE=D0=B2?= Date: Sat, 28 Dec 2024 09:14:47 +0300 Subject: [PATCH] 20241228 --- util.cs | 854 +++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 812 insertions(+), 42 deletions(-) diff --git a/util.cs b/util.cs index e18fd2a..659910c 100644 --- a/util.cs +++ b/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(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 getportnames() @@ -525,25 +532,25 @@ namespace UTIL case "Double": case "Single": case "Decimal": -// return Math.Round(Convert.ToDouble(value), 2).ToString("+0.00;-0.00;+0.00"); + // return Math.Round(Convert.ToDouble(value), 2).ToString("+0.00;-0.00;+0.00"); case "UInt64": case "UInt32": case "UInt16": case "Byte": -// return value.ToString(); -// return $"{value:+0;+0;+0}"; + // return value.ToString(); + // return $"{value:+0;+0;+0}"; case "Int64": case "Int32": case "Int16": case "SByte": -// return $"{value:+0;-0;+0}"; -// return value.ToString(); + // return $"{value:+0;-0;+0}"; + // return value.ToString(); case "String": -// return $"{value}"; -// return value.ToString(); + // return $"{value}"; + // return value.ToString(); case "Hex": -// return $"{value}"; -// return value.ToString(); + // return $"{value}"; + // return value.ToString(); default: break; } @@ -560,6 +567,16 @@ namespace UTIL return dmax; return dval; } + + //public T minmax(T min, T max, T val) where T : IComparable + //{ + // if (val.CompareTo(min) <= 0) + // return min; + // if (val.CompareTo(max) > 0) + // return max; + // return val; + //} + public struct Hex { private T _Value; @@ -662,7 +679,7 @@ namespace UTIL if (!sign) a = Convert.ToInt64(num).ToString().PadLeft(chars, ' '); else - a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' '); + a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' '); return a; default: return num.ToString(); @@ -699,29 +716,45 @@ namespace UTIL return num.ToString(); } } + #region создание нового имени файла из оригинального открытого с учетом дублей - //public static String NewFileName(String fullfilename, String newextention) - //{ - // if (!iofile.Exists(fullfilename.Replace(".bmp", "_00" + newextention))) - // return fullfilename.Replace(".bmp", "_00" + newextention); - // DirectoryInfo dir = new DirectoryInfo(iopath.GetDirectoryName(fullfilename)); - // String lastname; - // int lastnum = 0; - // String sss = ""; - // foreach (FileInfo item in dir.GetFiles("*" + newextention)) - // { - // //MessageBox.Show(item.FullName); - // if (item.FullName.StartsWith(fullfilename.Replace(".bmp", ""))) - // { - // lastname = item.FullName; - // lastnum = Convert.ToInt32(lastname.Replace(fullfilename.Replace(".bmp", ""), "").Replace(newextention, "").Remove(0, 1)); - // sss += lastname + "\r\n"; - // } - // } - // //MessageBox.Show(sss + "\r\n" + (lastnum + 1).ToString()); - // return fullfilename.Replace(".bmp", "") + "_" + (lastnum + 1).ToString("D2") + newextention; - //} + public static void NewFileName(Byte[] data, String filename, char delim = '_') + { + SaveFileDialog sfd = new SaveFileDialog(); + sfd.OverwritePrompt = false; + sfd.FileName = filename; + if (sfd.ShowDialog() != DialogResult.OK) + return; + + if (!File.Exists(sfd.FileName)) + filename = sfd.FileName; + + String fnamewoext = Path.GetFileNameWithoutExtension(filename); + String fileext = Path.GetExtension(filename); + String dirname = Path.GetDirectoryName(filename); + String fname = fnamewoext.Split(delim)[0]; + var directory = new DirectoryInfo(dirname == "" ? Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath):dirname); + FileInfo[] files = directory.GetFiles(fname + delim.ToString() + "???" + fileext); + String nextfn = ""; + if (files.Length > 0) + { + 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 bytes) + { + var crc = 0xffffffff; + foreach (var t in bytes) + { + var index = (byte)((crc & 0xff) ^ t); + crc = (crc >> 8) ^ _table[index]; + } + return ~crc; + } + + public IEnumerable ComputeChecksumBytes(IEnumerable 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 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[] _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()) + { + } + /// + /// Create a strongly typed property called TrackBar - handy to prevent casting everywhere. + /// + public TrackBar TrackBar + { + get + { + return Control as TrackBar; + } + } + /// + /// Create the actual control, note this is static so it can be called from the + /// constructor. + /// + /// + /// + 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; } + } + /// + /// Attach to events we want to re-wrap + /// + /// + [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); + } + /// + /// Detach from events. + /// + /// + protected override void OnUnsubscribeControlEvents(Control control) + { + base.OnUnsubscribeControlEvents(control); + TrackBar trackBar = control as TrackBar; + trackBar.ValueChanged -= new EventHandler(trackBar_ValueChanged); + } + /// + /// Routing for event + /// TrackBar.ValueChanged -> ToolStripTrackBar.ValueChanged + /// + /// + /// + 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()) + { + } + /// + /// Create a strongly typed property called TrackBar - handy to prevent casting everywhere. + /// + public NumericUpDown NumericUpDown + { + get + { + return Control as NumericUpDown; + } + } + /// + /// Create the actual control, note this is static so it can be called from the + /// constructor. + /// + /// + /// + 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; } + } + /// + /// Attach to events we want to re-wrap + /// + /// + [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); + } + /// + /// Detach from events. + /// + /// + protected override void OnUnsubscribeControlEvents(Control control) + { + base.OnUnsubscribeControlEvents(control); + NumericUpDown t = control as NumericUpDown; + t.ValueChanged -= new EventHandler(updown_ValueChanged); + } + /// + /// Routing for event + /// TrackBar.ValueChanged -> ToolStripTrackBar.ValueChanged + /// + /// + /// + 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 + }