dkuznets
/
c_sharp_lib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

20241228

20230911
Денис Кузнецов 1 year ago
parent
ff5f61f559
commit
8deea834eb
1 changed files with 812 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 832
      util.cs

832
util.cs
Unescape View File

@ -16,13 +16,15 @@ using System.Net.NetworkInformation; @@ -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 @@ -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 @@ -47,7 +48,6 @@ namespace UTIL
return Assembly.GetExecutingAssembly().GetName().Version.ToString();
}
}
public static string AssemblyDescription
{
get
@ -60,7 +60,6 @@ namespace UTIL @@ -60,7 +60,6 @@ namespace UTIL
return ((AssemblyDescriptionAttribute)attributes[0]).Description;
}
}
public static string AssemblyProduct
{
get
@ -77,7 +76,6 @@ namespace UTIL @@ -77,7 +76,6 @@ namespace UTIL
#endif
}
}
public static string AssemblyCopyright
{
get
@ -90,7 +88,6 @@ namespace UTIL @@ -90,7 +88,6 @@ namespace UTIL
return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
}
}
public static string AssemblyCompany
{
get
@ -189,9 +186,10 @@ namespace UTIL @@ -189,9 +186,10 @@ namespace UTIL
return s;
}
}
#endregion
}
#endregion
#region Работа с INI файлами
public class IniFile
{
[DllImport("kernel32.dll")]
@ -248,10 +246,11 @@ namespace UTIL @@ -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 @@ -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 @@ -352,7 +352,9 @@ namespace UTIL
}
}
}
#endregion
#region фильтр Калмана
public class GKalman
{
double _err_measure = 0.0F;
@ -395,7 +397,9 @@ namespace UTIL @@ -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 @@ -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 @@ -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 @@ -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 @@ -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 @@ -870,6 +1382,9 @@ namespace UTIL
_length++;
}
}
#endregion
#region Медианный фильтр
public class GMedian
{
UInt16[] bufUI16;
@ -1019,6 +1534,9 @@ namespace UTIL @@ -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 @@ -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 @@ -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 @@ -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
}

Write Preview
Loading…
Cancel
Save