using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Text; using System.Runtime.InteropServices; using System.Drawing; using System.Windows.Forms; using System.Windows.Forms.VisualStyles; using System.ComponentModel; using System.Drawing.Imaging; using System.Globalization; using static System.Net.Mime.MediaTypeNames; using System.Diagnostics; 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 { public static string AssemblyTitle { get { object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); if (attributes.Length > 0) { AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0]; if (titleAttribute.Title != "") { return titleAttribute.Title; } } return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); } } public static string AssemblyVersion { get { return Assembly.GetExecutingAssembly().GetName().Version.ToString(); } } public static string AssemblyDescription { get { object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); if (attributes.Length == 0) { return ""; } return ((AssemblyDescriptionAttribute)attributes[0]).Description; } } public static string AssemblyProduct { get { object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); if (attributes.Length == 0) { return ""; } #if DEBUG return ((AssemblyProductAttribute)attributes[0]).Product + " Debug version"; #else return ((AssemblyProductAttribute)attributes[0]).Product + " Release version"; #endif } } public static string AssemblyCopyright { get { object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); if (attributes.Length == 0) { return ""; } return ((AssemblyCopyrightAttribute)attributes[0]).Copyright; } } public static string AssemblyCompany { get { object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); if (attributes.Length == 0) { return ""; } return ((AssemblyCompanyAttribute)attributes[0]).Company; } } public static string AssemblyConfiguration { get { #if DEBUG return "Debug version"; #else return "Release version"; #endif } } public static string[] AssemblyConf { get { string[] s = new string[11]; object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyConfigurationAttribute), false); #if DEBUG s[0] = "Debug version"; #else s[0] = "Release version"; #endif attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyAlgorithmIdAttribute), false); if (attributes.Length == 0) s[1] = "AssemblyAlgorithmId = "; else s[1] = "AssemblyAlgorithmId = " + ((AssemblyAlgorithmIdAttribute)attributes[0]).AlgorithmId; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false); if (attributes.Length == 0) s[2] = "AssemblyCompany = "; else s[2] = "AssemblyCompany = " + ((AssemblyCompanyAttribute)attributes[0]).Company; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false); if (attributes.Length == 0) s[3] = "AssemblyCopyright = "; else s[3] = "AssemblyCopyright = " + ((AssemblyCopyrightAttribute)attributes[0]).Copyright; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false); if (attributes.Length == 0) s[4] = "AssemblyDescription = "; else s[4] = "AssemblyDescription = " + ((AssemblyDescriptionAttribute)attributes[0]).Description; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false); if (attributes.Length == 0) s[5] = "AssemblyFileVersion = "; else s[5] = "AssemblyFileVersion = " + ((AssemblyFileVersionAttribute)attributes[0]).Version; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false); if (attributes.Length == 0) s[6] = "AssemblyInformationalVersion = "; else s[6] = "AssemblyInformationalVersion = " + ((AssemblyInformationalVersionAttribute)attributes[0]).InformationalVersion; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false); if (attributes.Length == 0) s[7] = "AssemblyProduct = "; else s[7] = "AssemblyProduct = " + ((AssemblyProductAttribute)attributes[0]).Product; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false); if (attributes.Length == 0) s[8] = "AssemblyTitle = "; else s[8] = "AssemblyTitle = " + ((AssemblyTitleAttribute)attributes[0]).Title; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTrademarkAttribute), false); if (attributes.Length == 0) s[9] = "AssemblyTrademark = "; else s[9] = "AssemblyTrademark = " + ((AssemblyTrademarkAttribute)attributes[0]).Trademark; attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyVersionAttribute), false); if (attributes.Length == 0) s[10] = "AssemblyVersion = "; else s[10] = "AssemblyVersion = " + ((AssemblyVersionAttribute)attributes[0]).Version; return s; } } } #endregion #region Работа с INI файлами public class IniFile { [DllImport("kernel32.dll")] private extern static int GetPrivateProfileString(String AppName, String KeyName, String Default, StringBuilder ReturnedString, UInt32 Size, String FileName); [DllImport("kernel32.dll")] private extern static int WritePrivateProfileString(String AppName, String KeyName, String Str, String FileName); public IniFile(string filename) { IniFileName = filename; } public String IniFileName { get; set; } public String _GetString(String section, String key) { StringBuilder s1 = new StringBuilder(128); GetPrivateProfileString(section, key, "", s1, 128, IniFileName); return s1.ToString(); } public Int64 _GetInt(String section, String key) { StringBuilder s1 = new StringBuilder(100); GetPrivateProfileString(section, key, "", s1, 100, IniFileName); return Int64.Parse(s1.ToString()); } public Boolean _GetBool(String section, String key) { StringBuilder s1 = new StringBuilder(100); GetPrivateProfileString(section, key, "", s1, 100, IniFileName); return Boolean.Parse(s1.ToString()); } public Double _GetDouble(String section, String key) { StringBuilder s1 = new StringBuilder(100); GetPrivateProfileString(section, key, "", s1, 100, IniFileName); return Double.Parse(s1.ToString()); } public void _SetString(String section, String key, String val) { WritePrivateProfileString(section, key, val, IniFileName); } public void _SetInt(String section, String key, Int64 val) { WritePrivateProfileString(section, key, val.ToString(), IniFileName); } public void _SetDouble(String section, String key, Double val) { WritePrivateProfileString(section, key, val.ToString(), IniFileName); } public void _SetBool(String section, String key, Boolean val) { WritePrivateProfileString(section, key, val.ToString(), IniFileName); } } #endregion #region Загрузка/выгрузка данных в структуру public static class S2B { //public static T BuffToStruct(byte[] arr) //{ // GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); // IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); // T ret = (T)Marshal.PtrToStructure(ptr, typeof(T)); // gch.Free(); // return default(T); //} public static T BuffToStruct(byte[] arr) { GCHandle handle = GCHandle.Alloc(arr, GCHandleType.Pinned); T stuff = (T)Marshal.PtrToStructure( handle.AddrOfPinnedObject(), typeof(T)); handle.Free(); return stuff; } public static T BuffToClass(byte[] arr) { GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); T ret = (T)Marshal.PtrToStructure(ptr, typeof(T)); gch.Free(); return default(T); } public static byte[] StructToBuff(T value) where T : struct { byte[] arr = new byte[Marshal.SizeOf(value)]; // создать массив GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); // зафиксировать в памяти IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); // и взять его адрес Marshal.StructureToPtr(value, ptr, true); // копировать в массив gch.Free(); // снять фиксацию return arr; } public static byte[] ClassToBuff(T value) where T : class { byte[] arr = new byte[Marshal.SizeOf(value)]; // создать массив GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); // зафиксировать в памяти IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); // и взять его адрес Marshal.StructureToPtr(value, ptr, true); // копировать в массив gch.Free(); // снять фиксацию return arr; } } #endregion #region Расширенные методы RichTextBox public static class RichTextBoxExtensions { public static void AppendText(this RichTextBox box, string text, Color color) { if (box.InvokeRequired) { box.Invoke((MethodInvoker)(delegate { box.SelectionStart = box.TextLength; box.SelectionLength = 0; box.SelectionColor = color; box.AppendText(text); box.SelectionColor = box.ForeColor; box.ScrollToCaret(); })); } else { box.SelectionStart = box.TextLength; box.SelectionLength = 0; box.SelectionColor = color; box.AppendText(text); box.SelectionColor = box.ForeColor; box.ScrollToCaret(); } } public static void AppendText(this RichTextBox box, string text, Color bgcolor, Color fgcolor) { if (box.InvokeRequired) { box.Invoke((MethodInvoker)(delegate { box.SelectionStart = box.TextLength; box.SelectionLength = 0; box.SelectionColor = fgcolor; box.SelectionBackColor = bgcolor; box.AppendText(text); box.SelectionColor = box.ForeColor; box.SelectionBackColor = box.BackColor; box.ScrollToCaret(); })); } else { box.SelectionStart = box.TextLength; box.SelectionLength = 0; box.SelectionColor = fgcolor; box.SelectionBackColor = bgcolor; box.AppendText(text); box.SelectionColor = box.ForeColor; box.SelectionBackColor = box.BackColor; box.ScrollToCaret(); } } } #endregion #region фильтр Калмана public class GKalman { double _err_measure = 0.0F; double _err_estimate = 0.0F; double _q = 0.0F; double _last_estimate = 0.0F; public GKalman(double mea_e, double est_e, double q) { setParameters(mea_e, est_e, q); } // разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки) public GKalman(double mea_e, double q) { setParameters(mea_e, mea_e, q); } // разброс измерения, разброс оценки, скорость изменения значений public void setParameters(double mea_e, double est_e, double q) { _err_measure = mea_e; _err_estimate = est_e; _q = q; } // разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки) public void setParameters(double mea_e, double q) { setParameters(mea_e, mea_e, q); } // возвращает фильтрованное значение public double filtered(double value) { double _kalman_gain, _current_estimate; _kalman_gain = _err_estimate / (_err_estimate + _err_measure); _current_estimate = _last_estimate + _kalman_gain * (value - _last_estimate); _err_estimate = (1.0 - _kalman_gain) * _err_estimate + Math.Abs(_last_estimate - _current_estimate) * _q; _last_estimate = _current_estimate; return (double)_current_estimate; } } #endregion #region unsafe методы работы с изображением public unsafe class UnsafeBitmap { Bitmap bitmap; // three elements used for MakeGreyUnsafe int width; BitmapData bitmapData = null; Byte* pBase = null; public UnsafeBitmap(Bitmap bitmap) { this.bitmap = new Bitmap(bitmap); } public UnsafeBitmap(int width, int height) { this.bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb); } public void Dispose() { bitmap.Dispose(); } public Bitmap Bitmap { get { return (bitmap); } } private Point PixelSize { get { GraphicsUnit unit = GraphicsUnit.Pixel; RectangleF bounds = bitmap.GetBounds(ref unit); return new Point((int)bounds.Width, (int)bounds.Height); } } public void LockBitmap() { GraphicsUnit unit = GraphicsUnit.Pixel; RectangleF boundsF = bitmap.GetBounds(ref unit); Rectangle bounds = new Rectangle((int)boundsF.X, (int)boundsF.Y, (int)boundsF.Width, (int)boundsF.Height); // Figure out the number of bytes in a row // This is rounded up to be a multiple of 4 // bytes, since a scan line in an image must always be a multiple of 4 bytes // in length. width = (int)boundsF.Width * sizeof(PixelData); if (width % 4 != 0) { width = 4 * (width / 4 + 1); } bitmapData = bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); pBase = (Byte*)bitmapData.Scan0.ToPointer(); } public PixelData GetPixel(int x, int y) { PixelData returnValue = *PixelAt(x, y); return returnValue; } public void SetPixel(int x, int y, PixelData colour) { PixelData* pixel = PixelAt(x, y); *pixel = colour; } public void UnlockBitmap() { bitmap.UnlockBits(bitmapData); bitmapData = null; pBase = null; } public PixelData* PixelAt(int x, int y) { return (PixelData*)(pBase + y * width + x * sizeof(PixelData)); } } public struct PixelData { public byte blue; public byte green; public byte red; } #endregion #region мелкие функции public static class Util { public static List getportnames() { List list = new List(); try { String[] ports = System.IO.Ports.SerialPort.GetPortNames(); foreach (var item in ports) { try { SerialPort sp_tmp = new SerialPort(item); sp_tmp.Open(); sp_tmp.Close(); } catch (Exception) { continue; } list.Add(item); } } catch { return null; } return list; } public static String Val(Object value) { // Console.WriteLine(value.GetType()); // String tmp = value.GetType().ToString().Split(new Char[] { '.' })[1]; String tmp; tmp = value.GetType().ToString(); Console.WriteLine(tmp); tmp = value.GetType().ToString().Split(new Char[] { '.' })[1]; Console.WriteLine(tmp); switch (tmp) { case "Double": case "Single": case "Decimal": // 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}"; case "Int64": case "Int32": case "Int16": case "SByte": // return $"{value:+0;-0;+0}"; // return value.ToString(); case "String": // return $"{value}"; // return value.ToString(); case "Hex": // return $"{value}"; // return value.ToString(); default: break; } return ""; } public static T minmax(T min, T max, T val) { dynamic dmin = min; dynamic dmax = max; dynamic dval = val; if (dval <= dmin) return dmin; if (dval > dmax) 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; public static implicit operator Hex(T value) { return new Hex { _Value = value }; } public static implicit operator T(Hex value) { return value._Value; } public override string ToString() { if (_Value.GetType() == typeof(UInt64)) return $"{_Value:X016}"; if (_Value.GetType() == typeof(UInt32)) return $"{_Value:X08}"; if (_Value.GetType() == typeof(UInt16)) return $"{_Value:X04}"; if (_Value.GetType() == typeof(Byte)) return $"{_Value:X02}"; return _Value.ToString(); } } public struct Hex0x { private T _Value; private CultureInfo ci;// = new CultureInfo("ru-Ru"); public static implicit operator Hex0x(T value) { return new Hex0x { _Value = value }; } public static implicit operator T(Hex0x value) { return value._Value; } public override string ToString() { if (_Value.GetType() == typeof(UInt64)) return $"0x{_Value:X016}"; if (_Value.GetType() == typeof(UInt32)) return $"0x{_Value:X08}"; if (_Value.GetType() == typeof(UInt16)) return $"0x{_Value:X04}"; if (_Value.GetType() == typeof(Byte)) return $"0x{_Value:X02}"; return _Value.ToString(); } } public static String printtime(Boolean ms) { if (ms == true) return DateTime.Now.ToString("HH:mm:ss:fff "); else return DateTime.Now.ToString("HH:mm:ss "); } public static String printdatetime(Boolean ms) { if (ms == true) return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff "); else return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss "); } private const int EM_SETTABSTOPS = 0x00CB; [DllImport("User32.dll", CharSet = CharSet.Auto)] public static extern IntPtr SendMessage(IntPtr h, int msg, int wParam, int[] lParam); public static void SetTabWidth(TextBox textbox, int tabWidth) { Graphics graphics = textbox.CreateGraphics(); var characterWidth = (int)graphics.MeasureString("M", textbox.Font).Width; SendMessage (textbox.Handle , EM_SETTABSTOPS , 1 , new int[] { tabWidth * characterWidth } ); } public static String Format(T num, UInt16 chars, Boolean sign) { String tmp = num.GetType().ToString().Split(new Char[] { '.' })[1]; String a = ""; switch (tmp) { case "Double": case "Single": case "Decimal": if (!sign) a = Math.Round(Convert.ToDouble(num), 0).ToString().PadLeft(chars, ' '); else a = Math.Round(Convert.ToDouble(num), 0).ToString("+0;-#").PadLeft(chars, ' '); return a; case "UInt64": case "UInt32": case "UInt16": case "Byte": case "Int64": case "Int32": case "Int16": case "SByte": if (!sign) a = Convert.ToInt64(num).ToString().PadLeft(chars, ' '); else a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' '); return a; default: return num.ToString(); } } public static String Format(T num, UInt16 chars, Boolean sign, UInt16 round) { String tmp = num.GetType().ToString().Split(new Char[] { '.' })[1]; String a = ""; switch (tmp) { case "Double": case "Single": case "Decimal": if (!sign) a = Math.Round(Convert.ToDouble(num), round).ToString().PadLeft(chars, ' '); else a = Math.Round(Convert.ToDouble(num), round).ToString("+0;-#").PadLeft(chars, ' '); return a; case "UInt64": case "UInt32": case "UInt16": case "Byte": case "Int64": case "Int32": case "Int16": case "SByte": if (!sign) a = Convert.ToInt64(num).ToString().PadLeft(chars, ' '); else a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' '); return a; default: return num.ToString(); } } #region создание нового имени файла из оригинального открытого с учетом дублей 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) { var searcher = new ManagementObjectSearcher(@"Select * From Win32_PnPDevice"); var s = ""; if (pid != "") s = $"PID_{pid}"; else if (vid != "") s = $"VID_{vid}"; foreach (var device in searcher.Get()) { if (device.ToString().Contains(s)) { String q1 = device.GetPropertyValue("SameElement").ToString().Replace("\"", "").Split('=')[1]; String q2 = device.GetPropertyValue("SystemElement").ToString().Replace("\"", "").Split('=')[1]; char[] sss = new char[] { '\\', '&' }; String[] q3 = q2.Split(sss, StringSplitOptions.RemoveEmptyEntries); return (q1, q3[2].Remove(0, 4), q3[1].Remove(0, 4)); } } 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; Int32 _head; Int32 _tail; Int32 _length; Int32 _bufferSize; Int32 _pos; Object _lock = new object(); public CircularBuffer(Int32 bufferSize) { _buffer = new T[bufferSize]; _bufferSize = bufferSize; _head = bufferSize - 1; _tail = 0; _length = 0; } public Int32 Count { get { return _length; } } public Int32 Head { get { return _head; } } public Int32 Tail { get { return _tail; } } public bool IsEmpty { get { return _length == 0; } } public bool IsFull { get { return _length == _bufferSize; } } public bool IsNoData { get { return _tail + _pos >= _head; } } public T Dequeue() { if (IsEmpty) throw new InvalidOperationException("Queue exhausted"); T dequeued = _buffer[_tail]; _tail = NextPosition(_tail); _length--; return dequeued; } public T Peek(int pos) { _pos = pos; if (IsEmpty) throw new InvalidOperationException("Queue exhausted"); if (_tail + pos > _head) throw new InvalidOperationException("End data"); T dequeued = _buffer[_tail + pos]; return dequeued; } public T Peek() { if (IsEmpty) throw new InvalidOperationException("Queue exhausted"); if (_tail > _head) throw new InvalidOperationException("End data"); T dequeued = _buffer[_tail]; return dequeued; } private int NextPosition(int position) { return (position + 1) % _bufferSize; } public void Enqueue(T toAdd) { _head = NextPosition(_head); _buffer[_head] = toAdd; if (IsFull) _tail = NextPosition(_tail); else _length++; } } public class CircularBuffer2 { T[] _buffer; Int32 _head; Int32 _tail; Int32 _length; Int32 _bufferSize; Int32 _pos; Object _lock = new object(); public CircularBuffer2(Int32 bufferSize) { _buffer = new T[bufferSize]; _bufferSize = bufferSize; _head = bufferSize - 1; _tail = 0; _length = 0; } public T Dequeue() { T dequeued = _buffer[_tail]; _tail = (_tail + 1) % _bufferSize; _length--; return dequeued; } public T Peek() { if (_length == 0) throw new InvalidOperationException("No data"); return _buffer[_tail]; } private int NextPosition(int position) { return (position + 1) % _bufferSize; } public void Enqueue(T toAdd) { _head = (_head + 1) % _bufferSize; _buffer[_head] = toAdd; if (_length == _bufferSize) _tail = (_tail + 1) % _bufferSize; else _length++; } } #endregion #region Медианный фильтр public class GMedian { UInt16[] bufUI16; Int16[] bufI16; UInt32[] bufUI32; Int32[] bufI32; Double[] bufd; Single[] buff; Byte _counter = 0; public GMedian(UInt16 num) { bufUI16 = new UInt16[num]; bufI16 = new Int16[num]; bufUI32 = new UInt32[num]; bufI32 = new Int32[num]; bufd = new Double[num]; buff = new Single[num]; _counter = 0; } /* #define SIZE 5 int32_t bufferaz[SIZE]; int32_t bufferum[SIZE]; uint8_t _countaz = 0; uint8_t _countum = 0; int32_t filteredAZ(int32_t newVal) { bufferaz[_countaz] = newVal; if ((_countaz < SIZE - 1) && (bufferaz[_countaz] > bufferaz[_countaz + 1])) { for (int i = _countaz; i < SIZE - 1; i++) { if (bufferaz[i] > bufferaz[i + 1]) { int32_t buff = bufferaz[i]; bufferaz[i] = bufferaz[i + 1]; bufferaz[i + 1] = buff; } } } else { if ((_countaz > 0) && (bufferaz[_countaz - 1] > bufferaz[_countaz])) { for (int i = _countaz; i > 0; i--) { if (bufferaz[i] < bufferaz[i - 1]) { int32_t buff = bufferaz[i]; bufferaz[i] = bufferaz[i - 1]; bufferaz[i - 1] = buff; } } } } if (++_countaz >= SIZE) _countaz = 0; return bufferaz[SIZE / 2]; } */ } public class GMedian where T : IComparable { private T[] buf; byte _count = 0; UInt16 _num = 0; public GMedian(UInt16 num) { buf = new T[num]; _count = 0; _num = num; } public T filtered(T newVal) { buf[_count] = newVal; if ((_count < _num - 1) && (buf[_count].CompareTo(buf[_count + 1]) > 0)) { for (int i = _count; i < _num - 1; i++) { if (buf[i].CompareTo(buf[i + 1]) > 0) { T buff = buf[i]; buf[i] = buf[i + 1]; buf[i + 1] = buff; } } } else { if ((_count > 0) && (buf[_count - 1].CompareTo(buf[_count])) > 0) { for (int i = _count; i > 0; i--) { if (buf[i].CompareTo(buf[i - 1]) < 0) { T buff = buf[i]; buf[i] = buf[i - 1]; buf[i - 1] = buff; } } } } if (++_count >= _num) _count = 0; return buf[_num / 2]; } /* #define SIZE 5 int32_t bufferaz[SIZE]; int32_t bufferum[SIZE]; uint8_t _countaz = 0; uint8_t _countum = 0; int32_t filteredAZ(int32_t newVal) { bufferaz[_countaz] = newVal; if ((_countaz < SIZE - 1) && (bufferaz[_countaz] > bufferaz[_countaz + 1])) { for (int i = _countaz; i < SIZE - 1; i++) { if (bufferaz[i] > bufferaz[i + 1]) { int32_t buff = bufferaz[i]; bufferaz[i] = bufferaz[i + 1]; bufferaz[i + 1] = buff; } } } else { if ((_countaz > 0) && (bufferaz[_countaz - 1] > bufferaz[_countaz])) { for (int i = _countaz; i > 0; i--) { if (bufferaz[i] < bufferaz[i - 1]) { int32_t buff = bufferaz[i]; bufferaz[i] = bufferaz[i - 1]; bufferaz[i - 1] = buff; } } } } if (++_countaz >= SIZE) _countaz = 0; return bufferaz[SIZE / 2]; } */ } #endregion #region Работа с сетевыми адаптерами public class SetNet { public void setIP(string caption, string ipaddress, Boolean dhcp) { // SetIP(EthStatic, "/c netsh interface ip set address \"" + EthName + "\" static " + Properties.Settings.Default.EthIPac + " " + Properties.Settings.Default.Subnet + " " + Properties.Settings.Default.EthDnsac + " & netsh interface ip set dns \"" + EthName + "\" static " + Properties.Settings.Default.EthDnsac); String arg = ""; if (!dhcp) { arg = $"/c netsh interface ipv4 set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\""; // arg = $"/c netsh interface ipv4 set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\" \"192.168.1.2\" & netsh interface ipv4 set dns \"{caption}\" static \"192.168.1.2\""; // arg = $"/c netsh interface ip set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\" \"192.168.1.2\" & netsh interface ip set dns \"{caption}\" static \"192.168.1.2\""; } else { arg = $"/c netsh interface ipv4 set address \"{caption}\" dhcp & netsh interface ipv4 set dns \"{caption}\" dhcp"; // arg = $"/c netsh interface ip set address \"{caption}\" dhcp & netsh interface ip set dns \"{caption}\" dhcp"; } try { ProcessStartInfo psi = new ProcessStartInfo("cmd.exe"); psi.UseShellExecute = true; psi.WindowStyle = ProcessWindowStyle.Hidden; psi.Verb = "runas"; psi.Arguments = arg; Process ps = Process.Start(psi); ps.WaitForExit(); if (ps.HasExited) { MessageBox.Show("Адрес изменен", "Информация", MessageBoxButtons.OK, MessageBoxIcon.Information); } } catch (Exception ex) { MessageBox.Show(ex.Message); } } public List getadapters() { List adapters = new List(); String ip = ""; String dns = ""; String nic = ""; String gw = ""; String dhcp = ""; String ipen = ""; String sub = ""; string[] NwDesc = { "TAP", "VMware", "Windows", "Virtual", "WAN", "Microsoft", "NDIS", "Bluetooth" }; // Adapter types (Description) to be ommited foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces()) { if (ni.NetworkInterfaceType == NetworkInterfaceType.Ethernet && !NwDesc.Any(ni.Description.Contains)) // check for adapter type and its description { nic = ni.Name; Console.WriteLine($"Name: {nic} # Desc: {ni.Description} # Mac: {ni.GetPhysicalAddress().ToString()} # Status: {ni.OperationalStatus}"); if (ni.GetIPProperties().UnicastAddresses.Count == 0) ip = ""; else { foreach (UnicastIPAddressInformation ips in ni.GetIPProperties().UnicastAddresses) { if (ips.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { ip = ips.Address.ToString(); } } } if (ni.GetIPProperties().DnsAddresses.Count == 0) dns = ""; else { foreach (IPAddress dnsAdress in ni.GetIPProperties().DnsAddresses) { if (dnsAdress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) { dns = dnsAdress.ToString(); } } } if (ni.GetIPProperties().GatewayAddresses.Count == 0) gw = ""; else { foreach (GatewayIPAddressInformation gwAdress in ni.GetIPProperties().GatewayAddresses) { gw = gwAdress.Address.ToString(); } } if (ni.GetIPProperties().DhcpServerAddresses.Count == 0) dhcp = ""; else { foreach (IPAddress dhcpAdress in ni.GetIPProperties().DhcpServerAddresses) { dhcp = dhcpAdress.ToString(); } } sub = "255.255.255.0"; if (ni.OperationalStatus.ToString() == "Down") ipen = "False"; else ipen = "True"; // Caption IPAddress IPSubnet DHCPEnabled IPEnabled Console.WriteLine($"{nic}-{ip}-{sub}-{dhcp}-{ipen}"); adapters.Add(new String[] { ni.Description, ip, sub, (dhcp == "" ? "False" : "True"), ipen, nic }); } } return adapters; } } #endregion #region Медианный фильтр 2 public class GMedian3 { public UInt16 filtered(UInt16 value) { // возвращает фильтрованное значение bufUI16[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(bufUI16[0], bufUI16[1]) == Math.Max(bufUI16[1], bufUI16[2])) ? Math.Max(bufUI16[0], bufUI16[2]) : Math.Max(bufUI16[1], Math.Min(bufUI16[0], bufUI16[2])); } public Int16 filtered(Int16 value) { // возвращает фильтрованное значение bufI16[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(bufI16[0], bufI16[1]) == Math.Max(bufI16[1], bufI16[2])) ? Math.Max(bufI16[0], bufI16[2]) : Math.Max(bufI16[1], Math.Min(bufI16[0], bufI16[2])); } public UInt32 filtered(UInt32 value) { // возвращает фильтрованное значение bufUI32[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(bufUI32[0], bufUI32[1]) == Math.Max(bufUI32[1], bufUI32[2])) ? Math.Max(bufUI32[0], bufUI32[2]) : Math.Max(bufUI32[1], Math.Min(bufUI32[0], bufUI32[2])); } public Int32 filtered(Int32 value) { // возвращает фильтрованное значение bufI32[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(bufI32[0], bufI32[1]) == Math.Max(bufI32[1], bufI32[2])) ? Math.Max(bufI32[0], bufI32[2]) : Math.Max(bufI32[1], Math.Min(bufI32[0], bufI32[2])); } public float filtered(float value) { // возвращает фильтрованное значение buff[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(buff[0], buff[1]) == Math.Max(buff[1], buff[2])) ? Math.Max(buff[0], buff[2]) : Math.Max(buff[1], Math.Min(buff[0], buff[2])); } public Double filtered(Double value) { // возвращает фильтрованное значение bufd[_counter] = value; if (++_counter > 2) _counter = 0; return (Math.Max(bufd[0], bufd[1]) == Math.Max(bufd[1], bufd[2])) ? Math.Max(bufd[0], bufd[2]) : Math.Max(bufd[1], Math.Min(bufd[0], bufd[2])); } UInt16[] bufUI16 = new UInt16[3]; Int16[] bufI16 = new Int16[3]; UInt32[] bufUI32 = new UInt32[3]; Int32[] bufI32 = new Int32[3]; Double[] bufd = new Double[3]; 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)>(); private int _num = 0; private (bool, string, string, bool, string) nullitem = (false, null, null, false, null); public int NumofPar { get; } public (bool, string, string, bool, string) GetPar(UInt16 num) { if (Pars[num].Item1) return Pars[num]; else return nullitem; } public (bool, string, string, bool, string) GetPar(String par) { for (int j = 0; j < _num; j++) { if ((par == Pars[j].Item2 || par == Pars[j].Item3) && Pars[j].Item1) return Pars[j]; } return nullitem; } public void AddPar(String shrt, String lng, Boolean key) { Pars.Add((false, shrt, lng, key, "")); _num = Pars.Count; } public int Parse(String[] arg) { int rez = 0; if (_num == 0) return -1; if (arg.Length == 0) return -1; for (int i = 0; i < arg.Length; i++) { for (int j = 0; j < _num; j++) { if (arg[i] == Pars[j].Item2 || arg[i] == Pars[j].Item3) { (bool, string, string, bool, string) tmp = Pars[j]; if (Pars[j].Item4) { tmp.Item5 = arg[i + 1]; } tmp.Item1 = true; Pars[j] = tmp; rez++; } } } 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 }