public short rdShort(string Module, int pOffset) { return(BitConverter.ToInt16(this.rdMem(this.DllImageAddress(Module) + pOffset, 2), 0)); }
protected virtual void OnReceivedInternal(byte[] data, int offset, int count) { if (data != null && count >= ReceiveBufferLength) { double[] result = new double[4]; result[0] = BitConverter.ToInt16(data, offset + 2); result[1] = BitConverter.ToInt16(data, offset + 4); result[2] = BitConverter.ToInt16(data, offset + 6); result[3] = BitConverter.ToInt16(data, offset + 8); switch (data[1]) { case 0x50: //ChipTime break; case 0x51: //Gravity this.GravityDataReceivedEvent( new Vector3D( result[0] / 32768.0 * 16.0, result[1] / 32768.0 * 16.0, result[2] / 32768.0 * 16.0 ) ); break; case 0x52: //AngleSpeed this.AngleSpeedDataReceivedEvent( new Vector3D( result[0] / 32768.0 * 2000.0, result[1] / 32768.0 * 2000.0, result[2] / 32768.0 * 2000.0 ) ); break; case 0x53: //AngleValue this.AngleValueDataReceivedEvent( new Vector3D( result[0] / 32768.0 * 180.0, result[1] / 32768.0 * 180.0, result[2] / 32768.0 * 180.0 ) ); break; case 0x54: //Magnet this.MagnetDataReceivedEvent( new Vector3D( result[0] / 32768.0 * 1200.0 * 2.0, result[1] / 32768.0 * 1200.0 * 2.0, result[2] / 32768.0 * 1200.0 * 2.0 ) ); break; case 0x55: //PortVoltage //PortVoltage[0] = Data[0]; //PortVoltage[1] = Data[1]; //PortVoltage[2] = Data[2]; //PortVoltage[3] = Data[3]; break; case 0x56: //Pressure = BitConverter.ToInt32(byteTemp, 2); //Altitude = (double)BitConverter.ToInt32(byteTemp, 6) / 100.0; break; case 0x57: //Longitude = BitConverter.ToInt32(byteTemp, 2); //Latitude = BitConverter.ToInt32(byteTemp, 6); break; case 0x58: //GPSHeight = (double)BitConverter.ToInt16(byteTemp, 2) / 10.0; //GPSYaw = (double)BitConverter.ToInt16(byteTemp, 4) / 10.0; //GroundVelocity = BitConverter.ToInt16(byteTemp, 6) / 1e3; break; default: break; } } }
/// <summary> /// Swaps endian of structure members that correspond to numerical types. /// Does not traverse nested structures. /// </summary> /// <returns>The structure with its members endian swapped.</returns> /// <param name="str">The structure.</param> public static object SwapStructureMembersEndian(object str) { Type t = str.GetType(); FieldInfo[] fieldInfo = t.GetFields(); foreach (FieldInfo fi in fieldInfo) { if (fi.FieldType == typeof(short)) { short int16 = (short)fi.GetValue(str); byte[] int16_b = BitConverter.GetBytes(int16); byte[] int16_r = int16_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToInt16(int16_r, 0)); } else if (fi.FieldType == typeof(int)) { int int32 = (int)fi.GetValue(str); byte[] int32_b = BitConverter.GetBytes(int32); byte[] int32_r = int32_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToInt32(int32_r, 0)); } else if (fi.FieldType == typeof(long)) { long int64 = (long)fi.GetValue(str); byte[] int64_b = BitConverter.GetBytes(int64); byte[] int64_r = int64_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToInt64(int64_r, 0)); } else if (fi.FieldType == typeof(ushort)) { ushort uint16 = (ushort)fi.GetValue(str); byte[] uint16_b = BitConverter.GetBytes(uint16); byte[] uint16_r = uint16_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToUInt16(uint16_r, 0)); } else if (fi.FieldType == typeof(uint)) { uint uint32 = (uint)fi.GetValue(str); byte[] uint32_b = BitConverter.GetBytes(uint32); byte[] uint32_r = uint32_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToUInt32(uint32_r, 0)); } else if (fi.FieldType == typeof(ulong)) { ulong uint64 = (ulong)fi.GetValue(str); byte[] uint64_b = BitConverter.GetBytes(uint64); byte[] uint64_r = uint64_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToUInt64(uint64_r, 0)); } else if (fi.FieldType == typeof(float)) { float flt = (float)fi.GetValue(str); byte[] flt_b = BitConverter.GetBytes(flt); byte[] flt_r = flt_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToSingle(flt_r, 0)); } else if (fi.FieldType == typeof(double)) { double dbl = (double)fi.GetValue(str); byte[] dbl_b = BitConverter.GetBytes(dbl); byte[] dbl_r = dbl_b.Reverse().ToArray(); fi.SetValue(str, BitConverter.ToDouble(dbl_r, 0)); } else if (fi.FieldType == typeof(byte) || fi.FieldType == typeof(sbyte)) { // Do nothing, can't byteswap them! } else if (fi.FieldType == typeof(Guid)) { // TODO: Swap GUID } // TODO: Swap arrays and enums else if (fi.FieldType.IsValueType && !fi.FieldType.IsEnum && !fi.FieldType.IsArray) { object obj = fi.GetValue(str); Type ty = obj.GetType(); object strc = SwapStructureMembersEndian(obj); fi.SetValue(str, strc); } } return(str); }
/// <summary> /// This register contains the roll of the device. /// The sensor data is represented as a signed 16-bit integer. /// 1degree = 16 int. /// </summary> /// <returns>Euler angles roll</returns> public int EulRoll(int remoteId = 0) { byte[] data = ReadRegister(0x68, 2, null, remoteId); return(BitConverter.ToInt16(data, 0)); }
/// <summary> /// Read a Short from the Buffer /// </summary> /// <returns></returns> public short ReadShort() { return(BitConverter.ToInt16(ReadBigEndianBytes(2), 0)); }
int readShort(BinaryReader reader) { byte[] charData = reader.ReadBytes(2); Array.Reverse(charData); return(BitConverter.ToInt16(charData, 0)); }
public short ToInt16(uint offset = 0) { return(BitConverter.ToInt16(Bytes, (int)offset)); }
public short ReadInt16(int offset) { return(BitConverter.ToInt16(m_bytes, m_readoffset + offset)); }
public static void dtSwapEndian(ref short v) { byte[] bytes = BitConverter.GetBytes(v); System.Array.Reverse(bytes); v = BitConverter.ToInt16(bytes, 0); }
public Save(string folder, bool skipVersionCheck = false) { this.SaveFolder = folder; if (!File.Exists(Path.Combine(this.SaveFolder, "option.sav"))) { throw new ArgumentException("The selected folder is not a valid Breath of the Wild save folder. " + "Please select a folder containing valid save data, including option.sav " + "in the root of the folder."); } using (FileStream fs = new FileStream(Path.Combine(this.SaveFolder, "option.sav"), FileMode.Open)) using (BinaryReader br = new BinaryReader(fs)) { byte[] check = br.ReadBytes(1); this.SaveConsoleType = ByteArrayToString(check) == "00" ? SaveType.WiiU : SaveType.Switch; } foreach (string file in Directory.EnumerateFiles(this.SaveFolder, "game_data.sav", SearchOption.AllDirectories)) { using (FileStream fs = new FileStream(file, FileMode.Open)) using (BinaryReader br = new BinaryReader(fs)) { // Not a reliable way to determine game version //this.GameVersion = versionList[filesizes.IndexOf((int)f.Length)]; if (this.SaveConsoleType == SaveType.WiiU) { while (ByteArrayToString(br.ReadBytes(1)) == "00") { } br.BaseStream.Position -= 1; byte[] backwardsHeader = br.ReadBytes(2); try { this.SaveVersionList.Add(versionList[headers.IndexOf(BitConverter.ToInt16(backwardsHeader.Reverse().ToArray(), 0))]); } catch (Exception e) { Console.WriteLine(e); if (!skipVersionCheck) { throw new UnsupportedSaveException( "The version of a numbered save folder you selected cannot be retrieved."); } } } else { try { if (BitConverter.ToInt16(br.ReadBytes(2), 0) == 0x2a46) { this.SaveVersionList.Add(versionList[headers.IndexOf(0x29c0)]); //v1.3.0 switch? return; } br.BaseStream.Position = 0; if (BitConverter.ToInt16(br.ReadBytes(2), 0) == 0x3ef9) { this.SaveVersionList.Add(versionList[headers.IndexOf(0x3ef8)]); //v1.3.3 switch? return; } br.BaseStream.Position = 0; this.SaveVersionList.Add(versionList[headers.IndexOf(BitConverter.ToInt16(br.ReadBytes(2), 0))]); } catch (Exception e) { Console.WriteLine(e); if (!skipVersionCheck) { throw new UnsupportedSaveException("The version of a numbered save folder you selected cannot be retrieved.") { IsSwitch = true }; } } } } } }
public T Read <T>(IntPtr address) where T : struct { object ret = default(T); var buffer = new byte[0]; if (typeof(T) == typeof(string)) { return((T)(object)ReadCString(address)); } buffer = ReadBytes(address, (uint)Marshal.SizeOf(typeof(T))); switch (Type.GetTypeCode(typeof(T))) { case TypeCode.Object: GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned); Marshal.PtrToStructure(handle.AddrOfPinnedObject(), ret); handle.Free(); break; case TypeCode.Boolean: ret = BitConverter.ToBoolean(buffer, 0); break; case TypeCode.Char: ret = BitConverter.ToChar(buffer, 0); break; case TypeCode.Byte: ret = buffer[0]; break; case TypeCode.Int16: ret = BitConverter.ToInt16(buffer, 0); break; case TypeCode.UInt16: ret = BitConverter.ToUInt16(buffer, 0); break; case TypeCode.Int32: ret = BitConverter.ToInt32(buffer, 0); break; case TypeCode.UInt32: ret = BitConverter.ToUInt32(buffer, 0); break; case TypeCode.Int64: ret = BitConverter.ToInt64(buffer, 0); break; case TypeCode.UInt64: ret = BitConverter.ToUInt64(buffer, 0); break; case TypeCode.Single: ret = BitConverter.ToSingle(buffer, 0); break; case TypeCode.Double: ret = BitConverter.ToDouble(buffer, 0); break; default: throw new NotSupportedException($"Unknown type {typeof(T).Name}."); } return((T)ret); }
internal static short DeserializeInt16(Stream stream) { byte[] buffer = new byte[2]; stream.Read(buffer, 0, 2); return(BitConverter.ToInt16(buffer, 0)); }
public Version30(byte[] rawBytes, string sourceFilename) { SourceFilename = sourceFilename; RawBytes = rawBytes; try { var headerBytes = new byte[84]; Buffer.BlockCopy(rawBytes, 0, headerBytes, 0, 84); Header = new Header(headerBytes); var fi = new FileInfo(sourceFilename); SourceCreatedOn = new DateTimeOffset(fi.CreationTimeUtc); SourceModifiedOn = new DateTimeOffset(fi.LastWriteTimeUtc); SourceAccessedOn = new DateTimeOffset(fi.LastAccessTimeUtc); //TODO factor out creation of File info blocks var fileInfoBytes = new byte[224]; Buffer.BlockCopy(rawBytes, 84, fileInfoBytes, 0, 224); FileMetricsOffset = BitConverter.ToInt32(fileInfoBytes, 0); FileMetricsCount = BitConverter.ToInt32(fileInfoBytes, 4); TraceChainsOffset = BitConverter.ToInt32(fileInfoBytes, 8); TraceChainsCount = BitConverter.ToInt32(fileInfoBytes, 12); FilenameStringsOffset = BitConverter.ToInt32(fileInfoBytes, 16); FilenameStringsSize = BitConverter.ToInt32(fileInfoBytes, 20); VolumesInfoOffset = BitConverter.ToInt32(fileInfoBytes, 24); VolumeCount = BitConverter.ToInt32(fileInfoBytes, 28); VolumesInfoSize = BitConverter.ToInt32(fileInfoBytes, 32); //at offset 36 there are 8 unknown values, seemingly empty TotalDirectoryCount = BitConverter.ToInt32(fileInfoBytes, 36); var runtimeBytes = new byte[64]; Buffer.BlockCopy(fileInfoBytes, 44, runtimeBytes, 0, 64); //var runtimeBytes = fileInfoBytes.Skip(44).Take(64).ToArray(); LastRunTimes = new List <DateTimeOffset>(); for (var i = 0; i < 8; i++) { var rawTime = BitConverter.ToInt64(runtimeBytes, i * 8); if (rawTime > 0) { LastRunTimes.Add(DateTimeOffset.FromFileTime(rawTime).ToUniversalTime()); } } //at offset 108 there are 16 bytes of unknown, possibly previous data from runtimes RunCount = BitConverter.ToInt32(fileInfoBytes, 124); var unknown0 = BitConverter.ToInt32(fileInfoBytes, 128); var unknown1 = BitConverter.ToInt32(fileInfoBytes, 132); //at offset 136 there is 88 bytes of unknown, empty values var unknown2 = BitConverter.ToInt32(fileInfoBytes, 128); var fileMetricsBytes = new byte[FileMetricsCount * 32]; Buffer.BlockCopy(rawBytes, FileMetricsOffset, fileMetricsBytes, 0, FileMetricsCount * 32); var tempIndex = 0; FileMetrics = new List <FileMetric>(); var fileMetricsTempBuffer = new byte[32]; while (tempIndex < fileMetricsBytes.Length) { Buffer.BlockCopy(fileMetricsBytes, tempIndex, fileMetricsTempBuffer, 0, 32); FileMetrics.Add(new FileMetric(fileMetricsBytes, false)); tempIndex += 32; } TraceChains = new List <TraceChain>(); var traceChainBytes = new byte[8 * TraceChainsCount]; Buffer.BlockCopy(rawBytes, TraceChainsOffset, traceChainBytes, 0, 8 * TraceChainsCount); var traceIndex = 0; var traceChainTempBuffer = new byte[8]; while (traceIndex < traceChainBytes.Length) { Buffer.BlockCopy(traceChainBytes, traceIndex, traceChainTempBuffer, 0, 8); TraceChains.Add(new TraceChain(traceChainTempBuffer, true)); traceIndex += 8; } var filenameStringsBytes = new byte[FilenameStringsSize]; Buffer.BlockCopy(rawBytes, FilenameStringsOffset, filenameStringsBytes, 0, FilenameStringsSize); var filenamesRaw = Encoding.Unicode.GetString(filenameStringsBytes); var fileNames = filenamesRaw.Split(new[] { '\0' }, StringSplitOptions.RemoveEmptyEntries); Filenames = new List <string>(); Filenames.AddRange(fileNames); var volumeInfoBytes = new byte[VolumesInfoSize]; Buffer.BlockCopy(rawBytes, VolumesInfoOffset, volumeInfoBytes, 0, VolumesInfoSize); VolumeInformation = new List <VolumeInfo>(); //TODO factor this out as they are all the same? //TODO better yet, add in all the unique stuff so it can be researched var volBytes = new byte[96]; for (var j = 0; j < VolumeCount; j++) { var skipSize = j * 96; Buffer.BlockCopy(volumeInfoBytes, skipSize, volBytes, 0, 96); var volDevOffset = BitConverter.ToInt32(volBytes, 0); var volDevNumChar = BitConverter.ToInt32(volBytes, 4); var ct = BitConverter.ToInt64(volBytes, 8); var devNameBytes = new byte[volDevNumChar * 2]; Buffer.BlockCopy(rawBytes, VolumesInfoOffset + volDevOffset, devNameBytes, 0, volDevNumChar * 2); var devName = Encoding.Unicode.GetString(devNameBytes); var sn = BitConverter.ToInt32(volBytes, 16).ToString("X"); VolumeInformation.Add(new VolumeInfo(volDevOffset, DateTimeOffset.FromFileTime(ct).ToUniversalTime(), sn, devName)); var fileRefOffset = BitConverter.ToInt32(volBytes, 20); var fileRefSize = BitConverter.ToInt32(volBytes, 24); var dirStringsOffset = BitConverter.ToInt32(volBytes, 28); var numDirectoryStrings = BitConverter.ToInt32(volBytes, 32); //filerefs are at VolumesInfoOffset + fileRefOffset var fileRefsIndex = VolumesInfoOffset + fileRefOffset; var fileRefBytes = new byte[fileRefSize]; Buffer.BlockCopy(rawBytes, fileRefsIndex, fileRefBytes, 0, fileRefSize); var fileRefVer = BitConverter.ToInt32(fileRefBytes, 0); var numFileRefs = BitConverter.ToInt32(fileRefBytes, 4); tempIndex = 8; var tempFileRefBytes = new byte[8]; while (tempIndex < fileRefBytes.Length && VolumeInformation.Last().FileReferences.Count < numFileRefs) { Buffer.BlockCopy(fileRefBytes, tempIndex, tempFileRefBytes, 0, 8); VolumeInformation.Last() .FileReferences.Add(new MFTInformation(tempFileRefBytes)); tempIndex += 8; } var dirStringsIndex = VolumesInfoOffset + dirStringsOffset; var dirStringsBytes = new byte[rawBytes.Length - dirStringsIndex]; Buffer.BlockCopy(rawBytes, dirStringsIndex, dirStringsBytes, 0, rawBytes.Length - dirStringsIndex); tempIndex = 0; for (var k = 0; k < numDirectoryStrings; k++) { var dirCharCount = BitConverter.ToInt16(dirStringsBytes, tempIndex) * 2 + 2; // double the count since its Unicode and add 2 extra for null char tempIndex += 2; var dirName = Encoding.Unicode.GetString(dirStringsBytes, tempIndex, dirCharCount).Trim('\0'); VolumeInformation.Last().DirectoryNames.Add(dirName); tempIndex += dirCharCount; } } } catch (Exception) { ParsingError = true; } }
public static object GetValue(ElementType etype, byte[] data) { switch (etype) { case ElementType.Boolean: if (data == null || data.Length < 1) { return(false); } return(BitConverter.ToBoolean(data, 0)); case ElementType.Char: if (data == null || data.Length < 2) { return((char)0); } return(BitConverter.ToChar(data, 0)); case ElementType.I1: if (data == null || data.Length < 1) { return((sbyte)0); } return((sbyte)data[0]); case ElementType.U1: if (data == null || data.Length < 1) { return((byte)0); } return(data[0]); case ElementType.I2: if (data == null || data.Length < 2) { return((short)0); } return(BitConverter.ToInt16(data, 0)); case ElementType.U2: if (data == null || data.Length < 2) { return((ushort)0); } return(BitConverter.ToUInt16(data, 0)); case ElementType.I4: if (data == null || data.Length < 4) { return((int)0); } return(BitConverter.ToInt32(data, 0)); case ElementType.U4: if (data == null || data.Length < 4) { return((uint)0); } return(BitConverter.ToUInt32(data, 0)); case ElementType.I8: if (data == null || data.Length < 8) { return((long)0); } return(BitConverter.ToInt64(data, 0)); case ElementType.U8: if (data == null || data.Length < 8) { return((ulong)0); } return(BitConverter.ToUInt64(data, 0)); case ElementType.R4: if (data == null || data.Length < 4) { return((float)0); } return(BitConverter.ToSingle(data, 0)); case ElementType.R8: if (data == null || data.Length < 8) { return((double)0); } return(BitConverter.ToDouble(data, 0)); case ElementType.String: if (data == null) { return(string.Empty); } return(Encoding.Unicode.GetString(data, 0, data.Length / 2 * 2)); case ElementType.Class: return(null); default: return(null); } }
public static void ProcessVariableData(PropertyInfo[] propertyList, object obj, byte[] sourceData, int index, bool[] IncludedFields) { if (propertyList != null && obj != null && sourceData != null && IncludedFields != null) { //@@@@ int position = index; for (int i = 0; i < IncludedFields.Length; i++) { if (position > sourceData.Length) { break; } if (IncludedFields[i]) { try { PropertyInfo prop = propertyList[i]; if (prop.PropertyType == typeof(bool?)) { //incoming must be byte--no way to translate other type at this point. bool?boolVal = Convert.ToBoolean(sourceData[position]); if (_log.IsInfoEnabled && boolVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, boolVal.Value.ToString()); } propertyList[i].SetValue(obj, boolVal, null); position += 1; } if (prop.PropertyType == typeof(int?)) { if (position + 4 < sourceData.Length) { int?intVal = BitConverter.ToInt32(sourceData, position); if (_log.IsInfoEnabled && intVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, intVal.Value.ToString()); } propertyList[i].SetValue(obj, intVal, null); } position += 4; } if (prop.PropertyType == typeof(ArtemisString)) { ArtemisString val = new ArtemisString(sourceData, position); if (_log.IsInfoEnabled && val != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, val.Value); } propertyList[i].SetValue(obj, val, null); position += val.Length * 2 + 4; } if (prop.PropertyType == typeof(float?)) { if (position + 4 < sourceData.Length) { float?floatVal = BitConverter.ToSingle(sourceData, position); propertyList[i].SetValue(obj, floatVal, null); if (_log.IsInfoEnabled && floatVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, floatVal.Value.ToString()); } } position += 4; } if (prop.PropertyType == typeof(byte?)) { if (_log.IsInfoEnabled) { _log.InfoFormat("Property {0} set to {1}", prop.Name, sourceData[position].ToString()); } propertyList[i].SetValue(obj, sourceData[position], null); position++; } if (prop.PropertyType == typeof(short?)) { if (position + 2 < sourceData.Length) { short?shortVal = BitConverter.ToInt16(sourceData, position); if (_log.IsInfoEnabled && shortVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, shortVal.Value.ToString()); } propertyList[i].SetValue(obj, shortVal, null); } position += 2; } if (prop.PropertyType == typeof(long?)) { if (position + 8 < sourceData.Length) { long?longVal = BitConverter.ToInt64(sourceData, position); if (_log.IsInfoEnabled && longVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, longVal.Value.ToString()); } propertyList[i].SetValue(obj, longVal, null); } position += 8; } if (prop.PropertyType == typeof(OrdinanceTypes?)) { OrdinanceTypes?OrdVal = (OrdinanceTypes?)sourceData[position++]; if (_log.IsInfoEnabled && OrdVal != null) { _log.InfoFormat("Property {0} set to {1}", prop.Name, OrdVal.Value.ToString()); } propertyList[i].SetValue(obj, OrdVal, null); position++; } } catch (Exception ex) { if (_log.IsWarnEnabled) { _log.Warn("Error getting bytes", ex); } } } else { if (_log.IsInfoEnabled) { _log.InfoFormat("Property {0} not included", propertyList[i].Name); } } } } }
public int MakeData(DataRow workRow, byte s, int sz, byte[] info_bytes, string sn, DateTime deviceTime) { //eventlog parsing DateTime logtime; UInt16 status; workRow = dt.NewRow(); switch (s) { case 0x10: //Startup control byte //info_bytes = rdr.ReadBytes(4); workRow[0] = sn; workRow[1] = "Power up"; logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); sz -= 4; addNewRow(s, workRow, dt); break; case 0x11: //Shutdown control byte //info_bytes = rdr.ReadBytes(4); workRow[0] = sn; workRow[1] = "ShutDown"; logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); sz -= 4; addNewRow(s, workRow, dt); break; case 0x20: //Gas readings (full record) //info_bytes = rdr.ReadBytes(22); workRow[0] = sn; workRow[1] = "Gas Reading"; logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); status = BitConverter.ToUInt16(info_bytes, 4); workRow[3] = Optionparse(status, ReadingStatusList); if ((status & (1 << 10)) == (1 << 10)) { workRow[4] = "Yes"; isBump = true; } else { workRow[4] = "No"; isBump = false; } if (H2SEnabled && isvalid(BitConverter.ToInt16(info_bytes, 6))) { workRow[5] = (BitConverter.ToInt16(info_bytes, 6) / 10.0).ToString("0.0"); workRow[6] = (BitConverter.ToUInt16(info_bytes, 8) / 10.0).ToString("0.0"); workRow[7] = (BitConverter.ToUInt16(info_bytes, 10) / 10.0).ToString("0.0"); } else { H2SEnabled = false; } if (COEnabled && isvalid(BitConverter.ToInt16(info_bytes, 18))) { workRow[8] = (BitConverter.ToInt16(info_bytes, 12) / 10.0).ToString("0.0"); workRow[9] = (BitConverter.ToUInt16(info_bytes, 14) / 10.0).ToString("0.0"); workRow[10] = (BitConverter.ToUInt16(info_bytes, 16) / 10.0).ToString("0.0"); } else { COEnabled = false; } if (O2Enabled && isvalid(BitConverter.ToInt16(info_bytes, 18))) { workRow[11] = (BitConverter.ToInt16(info_bytes, 18) / 10.0).ToString("0.0"); } else { O2Enabled = false; } if (LELEnabled && isvalid(BitConverter.ToInt16(info_bytes, 20))) { workRow[12] = (BitConverter.ToInt16(info_bytes, 20) / 10.0).ToString("0.0"); } else { LELEnabled = false; } sz -= 22; addNewRow(s, workRow, dt); break; case 0x21: //All gas readings & STEL/TWA are zero (compressed record) //info_bytes = rdr.ReadBytes(4); workRow[0] = sn; workRow[1] = "Gas Reading"; logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); if (isBump) { workRow[4] = "Yes"; } else { workRow[4] = "No"; } workRow[3] = ""; workRow[5] = "0.0"; workRow[6] = "0.0"; workRow[7] = "0.0"; workRow[8] = "0.0"; workRow[9] = "0.0"; workRow[10] = "0.0"; workRow[11] = "20.9"; workRow[12] = "0"; sz -= 4; addNewRow(s, workRow, dt); break; case 0x30: //Unit options workRow[0] = sn; //info_bytes = rdr.ReadBytes(6); UInt16 h = BitConverter.ToUInt16(info_bytes, 4); workRow[1] = "Unit Option"; workRow[2] = dt.Rows[dt.Rows.Count - 1][2]; workRow[18] = Optionparse(BitConverter.ToUInt32(info_bytes, 0), UnitOptionList); if (h == 0) { workRow[19] = "English"; } else if (h == 1) { workRow[19] = "French"; } else if (h == 2) { workRow[19] = "German"; } else if (h == 3) { workRow[19] = "Spanish"; } else if (h == 4) { workRow[19] = "Portugese"; } else { workRow[19] = "invalid"; } sz -= 6; addNewRow(s, workRow, dt); break; //H2S options//CO options//O2 options//LEL options case 0x40: case 0x41: case 0x42: case 0x43: //info_bytes = rdr.ReadBytes(28); workRow[0] = sn; workRow[2] = dt.Rows[dt.Rows.Count - 1][2]; workRow[20] = Optionparse(BitConverter.ToUInt16(info_bytes, 0), GasconfigOptionList); workRow[21] = BitConverter.ToUInt32(info_bytes, 2) / 86400; workRow[22] = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 6)).ToString("yyyy-MM-dd HH:mm:ss"); workRow[23] = BitConverter.ToUInt32(info_bytes, 10) / 86400; workRow[24] = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 14)).ToString("yyyy-MM-dd HH:mm:ss"); workRow[25] = (BitConverter.ToUInt16(info_bytes, 18) / 10.0).ToString("0.0"); workRow[26] = (BitConverter.ToUInt16(info_bytes, 20) / 10.0).ToString("0.0"); if (s == 0x40 || s == 0x41) { workRow[27] = (BitConverter.ToUInt16(info_bytes, 22) / 10.0).ToString("0.0"); workRow[28] = (BitConverter.ToUInt16(info_bytes, 24) / 10.0).ToString("0.0"); workRow[29] = BitConverter.ToUInt16(info_bytes, 26); } if (s == 0x40) { workRow[1] = "H2S Options"; H2SEnabled = true; } else if (s == 0x41) { workRow[1] = "CO Options"; COEnabled = true; } else if (s == 0x42) { workRow[1] = "O2 Options"; O2Enabled = true; } else if (s == 0x43) { workRow[1] = "LEL Options"; LELEnabled = true; } sz -= 28; addNewRow(s, workRow, dt); break; case 0x50: //STATUS(i.e. self-test failure, cal failure, etc.) workRow[0] = sn; //info_bytes = rdr.ReadBytes(9); logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[1] = "Status"; workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); workRow[13] = Optionparse(info_bytes[4], SensorStatusList); workRow[14] = Optionparse(info_bytes[5], SensorStatusList); workRow[15] = Optionparse(info_bytes[6], SensorStatusList); workRow[16] = Optionparse(info_bytes[7], SensorStatusList); workRow[17] = Optionparse(info_bytes[8], SensorStatusList); sz -= 9; addNewRow(s, workRow, dt); break; case 0x51: //Temperature //info_bytes = rdr.ReadBytes(7); workRow[0] = sn; workRow[1] = "Charging Alarm"; logtime = deviceTime.AddSeconds(BitConverter.ToUInt32(info_bytes, 0)); workRow[2] = logtime.ToString("yyyy/MM/dd HH:mm:ss"); workRow[3] = chargingAlarmParse(info_bytes[4]); workRow[30] = BitConverter.ToInt16(info_bytes, 5); sz -= 7; addNewRow(s, workRow, dt); break; } if ((s == 0x21)) { inZero++; } else { inZero = 0; } return(sz); }
private void MainForm_Load(object sender, EventArgs args) { var waveIn = new NAudio.Wave.WaveInEvent(); waveIn.DeviceNumber = 0; waveIn.WaveFormat = new NAudio.Wave.WaveFormat(16000, 1); waveIn.DataAvailable += (object waveSender, NAudio.Wave.WaveInEventArgs e) => { //Dynamic waveform buffer offset, i want to f*****g die btw short[] waveValues = new short[(int)(e.BytesRecorded * .55)]; for (int i = 0; i < e.BytesRecorded; i += 2) { waveValues[(i / 2) + ((waveValues.Length - e.BytesRecorded / 2) / 2)] = (short)(BitConverter.ToInt16(e.Buffer, i) / 50); } try { waveform.Invoke((MethodInvoker)(() => waveform.Series[0].Points.DataBindY(waveValues))); UpdateVolumeMeter(Math.Abs(waveValues[waveValues.Length / 2])); } catch (Exception ex) { Console.WriteLine(ex.Message); } }; waveIn.StartRecording(); new Thread((ThreadStart) delegate { while (true) { StreamingMicRecognizeAsync(10).Wait(); } }).Start(); //Volume meter de-incrimenter #region progressReset.Interval = 50; progressReset.Elapsed += (o, arg) => { if (progressBar.Value > 0) { progressBar.Invoke((MethodInvoker)(() => progressBar.Value--)); } }; progressReset.Start(); #endregion wave.ChartType = SeriesChartType.Area; wave.Color = Color.Blue; }
/// <summary> /// 从缓存中提取short结果 /// </summary> /// <param name="buffer">缓存数据</param> /// <param name="index">索引位置</param> /// <returns>short对象</returns> public virtual short TransInt16(byte[] buffer, int index) { return(BitConverter.ToInt16(buffer, index)); }
/// <summary> /// 如果返回的是错误码、抛出异常 ;其他情况返回空。 /// </summary> /// <param name="t"></param> /// <param name="channel"></param> /// <returns></returns> public static byte[] Receive(Collector.ITaskContext t, Collector.Channel.BaseChannel channel) { sendByte = t.GetTX(); buf.Clear(); #region switch (sendByte[1]) { case 0x03: recLength = (BitConverter.ToInt16(new byte[] { sendByte[sendByte.Length - 3], sendByte[sendByte.Length - 4] }, 0) * 2) + 5; break; case 0x06: recLength = sendByte.Length; break; case 0x10: recLength = 8; break; default: throw new Exception("发送指令中存在不支持的指令码:" + sendByte[1].ToString()); } #endregion sw.Restart(); while (sw.ElapsedMilliseconds < recLength + TimeOut) { buf.AddRange(channel.Read(recLength)); if (buf.Count > 2) //判断返回的是否有错误 { if (buf[1] != sendByte[1]) { buf.Clear(); return(buf.ToArray()); } } if (buf.Count >= recLength)//接收完指定长度后,判断crc是否通过 { sw.Stop(); if (!ModbusHelper.CheckDataCrc16(buf.ToArray()) || buf.Count != recLength) { } break; } } sw.Stop(); if (buf.Count > 0) { ErrorCount = 0; } else { ErrorCount++; } if (ErrorCount > 3) { throw new Exception("串口多次未读取到数据、请检查通讯是否有问题"); } return(buf.ToArray()); }
void _masterClient_GotGameUpdate(object sender, GameInstance.GameUpdateEventArgs e) { GamePlayer player = (GamePlayer)sender; if (e.Message == GameMessage.EndGame) { Trace.WriteLine("Ending Game: " + player.Device.User); lock (_gameDb) { Game.Completed = true; _gameDb.SubmitChanges(); } if (null != GameEnded) { GameEnded(this, new EventArgs()); } player.Close(); } else if (e.Message == GameMessage.AcceptUser) { Int16 queryStringLength = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(e.GameState, 0)); string queryString = System.Text.Encoding.ASCII.GetString(e.GameState, 2, queryStringLength); NameValueCollection queryBucket = System.Web.HttpUtility.ParseQueryString(queryString); string device = queryBucket["id"]; foreach (GamePlayer slave in _slaveClients) { if (string.Equals(slave.Device.Device, device, StringComparison.InvariantCultureIgnoreCase)) { slave.Device.Accepted = true; slave.SendUpdate(GameMessage.AcceptUserResponse, new byte[0]); break; } } SendGameInfo(); } else if (e.Message == GameMessage.RejectUser) { Int16 queryStringLength = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(e.GameState, 0)); string queryString = System.Text.Encoding.ASCII.GetString(e.GameState, 2, queryStringLength); NameValueCollection queryBucket = System.Web.HttpUtility.ParseQueryString(queryString); string device = queryBucket["id"]; foreach (GamePlayer slave in _slaveClients) { if (string.Equals(slave.Device.Device, device, StringComparison.InvariantCultureIgnoreCase)) { slave.SendUpdate(GameMessage.RejectUserResponse, new byte[0]); slave.Close(); _slaveClients.Remove(slave); break; } } SendGameInfo(); } else if (e.Message == GameMessage.Start) { this.Game.Ready = true; SendGameInfo(); Thread.Sleep(1500); player.SendUpdate(GameMessage.StartResponse, new byte[0]); } else if (e.Message == GameMessage.PushState) { //Int16 queryStringLength = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(e.GameState, 0)); //string queryString = System.Text.Encoding.ASCII.GetString(e.GameState, 2, queryStringLength); //NameValueCollection queryBucket = System.Web.HttpUtility.ParseQueryString(queryString); //byte[] buffer = new byte[e.GameState.Length + 10]; //Encoding.ASCII.GetBytes("mobilesrc").CopyTo(buffer, 0); //buffer[9] = 1; //e.GameState.CopyTo(buffer, 10); foreach (GamePlayer slave in _slaveClients) { Console.WriteLine("_masterClient_GotGameUpdate: " + slave.Device.User); //slave.SendUpdate(GameMessage.NOP, new byte[1500]); try { slave.SendUpdate(GameMessage.PushStateResponse, e.GameState); } catch (Exception ex) { Console.WriteLine("ERROR _masterClient_GotGameUpdate"); Console.WriteLine(ex.ToString()); } } } else { } }
protected override void OnPaint(PaintEventArgs e) { if (this.waveStream != null) { e.Graphics.CompositingQuality = CompositingQuality.HighQuality; e.Graphics.SmoothingMode = SmoothingMode.HighQuality; e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; this.waveStream.Position = 0L; byte[] buffer = new byte[this.samplesPerPixel * this.bytesPerSample]; WaveStream waveStream = this.waveStream; long startPosition = this.startPosition; Rectangle clipRectangle = e.ClipRectangle; long num1 = (long)(clipRectangle.Left * this.bytesPerSample * this.samplesPerPixel); long num2 = startPosition + num1; waveStream.Position = num2; clipRectangle = e.ClipRectangle; float x = (float)clipRectangle.X; while (true) { double num3 = (double)x; clipRectangle = e.ClipRectangle; double right = (double)clipRectangle.Right; if (num3 < right) { short num4 = 0; short num5 = 0; int num6 = this.waveStream.Read(buffer, 0, this.samplesPerPixel * this.bytesPerSample); if (num6 != 0) { for (int startIndex = 0; startIndex < num6; startIndex += 2) { short int16 = BitConverter.ToInt16(buffer, startIndex); if ((int)int16 < (int)num4) { num4 = int16; } if ((int)int16 > (int)num5) { num5 = int16; } } float num7 = (float)(((double)num4 - (double)short.MinValue) / (double)ushort.MaxValue); float num8 = (float)(((double)num5 - (double)short.MinValue) / (double)ushort.MaxValue); short num9 = 0; short num10 = 0; int num11 = this.waveStream.Read(buffer, 0, this.samplesPerPixel * this.bytesPerSample); this.waveStream.Position -= (long)(this.samplesPerPixel * this.bytesPerSample); if (num11 != 0) { for (int startIndex = 0; startIndex < num11; startIndex += 2) { short int16 = BitConverter.ToInt16(buffer, startIndex); if ((int)int16 < (int)num9) { num9 = int16; } if ((int)int16 > (int)num10) { num10 = int16; } } float num12 = (float)(((double)num9 - (double)short.MinValue) / (double)ushort.MaxValue); float num13 = (float)(((double)num10 - (double)short.MinValue) / (double)ushort.MaxValue); e.Graphics.DrawLine(new Pen(this.FillColor), x, (float)this.Height * num7, x, (float)this.Height * num8); e.Graphics.DrawLine(new Pen(this.LineColor, 1f), x, (float)this.Height * num7, x + 1f, (float)this.Height * num12); e.Graphics.DrawLine(new Pen(this.LineColor, 1f), x, (float)this.Height * num8, x + 1f, (float)this.Height * num13); ++x; } else { break; } } else { break; } } else { break; } } } base.OnPaint(e); }
/// <summary> /// Reads and returns a double byte. /// </summary> /// <param name="position">The position.</param> /// <returns></returns> public short ReadShort(long position = -1) { Position = position; return(BitConverter.ToInt16(Br.ReadBytes(2), 0)); }
/// <summary> /// This register contains the magnetic field strength along the x-axis of the Pozyx device. /// The sensor data is stored as a signed 16-bit integer. /// 1µT = 16 int. /// </summary> /// <returns>Magnemtometer data</returns> public int MagnX(int remoteId = 0) { byte[] data = ReadRegister(0x5A, 2, null, remoteId); return(BitConverter.ToInt16(data, 0)); }
private dynamic ParseHour9Response(byte[] bytes) { dynamic hour = Parse70Response(bytes); if (!hour.success) { return(hour); } hour.records = new List <dynamic>(); hour.channel = hour.body[0]; var rowsCount = hour.body[2]; hour.isEmpty = false; if (rowsCount == 0) { hour.success = true; hour.error = "данные за запрошенную дату отсутствуют"; hour.isEmpty = true; return(hour); } hour.date = new DateTime(hour.body[10 - 3] + 2000, hour.body[9 - 3], hour.body[8 - 3], hour.body[7 - 3], hour.body[6 - 3], 0); //время наработки var timeWork = new TimeSpan(BitConverter.ToUInt16(hour.body, 13 - 3), hour.body[12 - 3], hour.body[11 - 3]).TotalHours; hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Twork, hour.channel), timeWork, "ч", hour.date)); //накопленный на конец часа|суток объем при нормальных условиях, нм3 var volumeNormal = BitConverter.ToUInt32(hour.body, 19 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Vn, hour.channel), volumeNormal, "м³", hour.date)); //накопленный на конец часа|суток объем при рабочих условиях, м3 var volumeWork = BitConverter.ToUInt32(hour.body, 23 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Vw, hour.channel), volumeWork, "м³", hour.date)); //среднечасовое|среднесуточное значение расхода при нормальных условиях, нм3/час| нм3/сут var volumeConsumptionNormal = BitConverter.ToUInt32(hour.body, 27 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Qn, hour.channel), volumeConsumptionNormal, "м³", hour.date)); //среднечасовое|среднесуточное значение расхода при рабочих условиях, м3/час| м3/сут var volumeConsumptionWork = BitConverter.ToUInt32(hour.body, 31 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Qw, hour.channel), volumeConsumptionWork, "м³", hour.date)); //среднечасовое|среднесуточное значение давления, кПа var pressure = BitConverter.ToSingle(hour.body, 35 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.P, hour.channel), pressure, "кПа", hour.date)); //среднечасовое|среднесуточное знчение температуры, 0C var temperature = BitConverter.ToSingle(hour.body, 39 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.T, hour.channel), temperature, "°C", hour.date)); //время при НС0 var tns0 = BitConverter.ToInt16(hour.body, 43 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Tns0, hour.channel), tns0, "с", hour.date)); //время при НС1 var tns1 = BitConverter.ToInt16(hour.body, 45 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Tns1, hour.channel), tns1, "с", hour.date)); //время при НС2 var tns2 = BitConverter.ToInt16(hour.body, 47 - 3); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Tns2, hour.channel), tns2, "с", hour.date)); //время при НС3 var tns3 = BitConverter.ToInt16(hour.body, 46); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Tns3, hour.channel), tns3, "с", hour.date)); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Qns2, hour.channel), BitConverter.ToInt32(hour.body, 48), "н.м³", hour.date)); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Vns, hour.channel), BitConverter.ToInt32(hour.body, 52), "н.м³", hour.date)); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Fl_a, hour.channel), hour.body[59 - 3], "", hour.date)); hour.records.Add(MakeHourRecord(string.Format("{0}{1}", Glossary.Fl_b, hour.channel), BitConverter.ToInt16(hour.body, 60 - 3), "", hour.date)); return(hour); }
public short ReadShort() { return(BitConverter.ToInt16(get(2), 0)); }
public string GetDataAsString() { int index; switch (ValType) { case TagBuilder.ValueType.NullType: return(string.Empty); case TagBuilder.ValueType.StringType: var s = Encoding.Unicode.GetString(DataBytes).Trim('\0'); s = Regex.Replace(s, @"\p{C}+", ", "); return(s); case TagBuilder.ValueType.AnsiStringType: var sa = Encoding.GetEncoding(1252).GetString(DataBytes).Trim('\0'); sa = Regex.Replace(sa, @"\p{C}+", ", "); return(sa); case TagBuilder.ValueType.Int8Type: return(((sbyte)DataBytes[0]).ToString()); case TagBuilder.ValueType.UInt8Type: return(DataBytes[0].ToString()); case TagBuilder.ValueType.Int16Type: return(BitConverter.ToInt16(DataBytes, 0).ToString()); case TagBuilder.ValueType.UInt16Type: return(BitConverter.ToUInt16(DataBytes, 0).ToString()); case TagBuilder.ValueType.Int32Type: return(BitConverter.ToInt32(DataBytes, 0).ToString()); case TagBuilder.ValueType.UInt32Type: return(BitConverter.ToUInt32(DataBytes, 0).ToString()); case TagBuilder.ValueType.Int64Type: return(BitConverter.ToInt64(DataBytes, 0).ToString()); case TagBuilder.ValueType.UInt64Type: return(BitConverter.ToUInt64(DataBytes, 0).ToString()); case TagBuilder.ValueType.Real32Type: return(BitConverter.ToSingle(DataBytes, 0).ToString(CultureInfo.InvariantCulture)); case TagBuilder.ValueType.Real64Type: return(BitConverter.ToDouble(DataBytes, 0).ToString(CultureInfo.InvariantCulture)); case TagBuilder.ValueType.BoolType: return(BitConverter.ToBoolean(DataBytes, 0).ToString()); case TagBuilder.ValueType.BinaryType: return(BitConverter.ToString(DataBytes)); case TagBuilder.ValueType.GuidType: var g = new Guid(DataBytes); return(g.ToString()); case TagBuilder.ValueType.SizeTType: return(BitConverter.ToString(DataBytes)); case TagBuilder.ValueType.FileTimeType: var fts = DateTimeOffset.FromFileTime(BitConverter.ToInt64(DataBytes, 0)).ToUniversalTime(); return(fts.ToString("yyyy-MM-dd HH:mm:ss.fffffff")); case TagBuilder.ValueType.SysTimeType: var sts = GetSystemTime(DataBytes); return(sts.ToString("yyyy-MM-dd HH:mm:ss.fffffff")); case TagBuilder.ValueType.SidType: return(ConvertHexStringToSidString(DataBytes)); case TagBuilder.ValueType.HexInt32Type: return($"0x{BitConverter.ToInt32(DataBytes, 0):X}"); case TagBuilder.ValueType.HexInt64Type: return($"0x{BitConverter.ToInt64(DataBytes, 0):X}"); case TagBuilder.ValueType.EvtXml: case TagBuilder.ValueType.EvtHandle: return("UNKNOWN: Please submit to [email protected]!"); case TagBuilder.ValueType.BinXmlType: return("BinaryXML"); case TagBuilder.ValueType.ArrayUnicodeString: var tsu = Encoding.Unicode.GetString(DataBytes) .Split(new[] { '\0' }, StringSplitOptions.RemoveEmptyEntries); return(string.Join(", ", tsu).Trim('\0')); case TagBuilder.ValueType.ArrayAsciiString: var tsa = Encoding.GetEncoding(1252).GetString(DataBytes) .Split(new[] { '\0' }, StringSplitOptions.RemoveEmptyEntries); return(string.Join(", ", tsa).Trim('\0')); case TagBuilder.ValueType.Array64BitIntSigned: var a64i = new List <long>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToInt64(DataBytes, index); index += 8; a64i.Add(ul); } return(string.Join(",", a64i)); case TagBuilder.ValueType.Array64BitIntUnsigned: var a64ui = new List <ulong>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToUInt64(DataBytes, index); index += 8; a64ui.Add(ul); } return(string.Join(",", a64ui)); case TagBuilder.ValueType.Array16BitIntUnsigned: var a16ui = new List <ushort>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToUInt16(DataBytes, index); index += 2; a16ui.Add(ul); } return(string.Join(",", a16ui)); case TagBuilder.ValueType.Array16BitIntSigned: var a16i = new List <short>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToInt16(DataBytes, index); index += 2; a16i.Add(ul); } return(string.Join(",", a16i)); case TagBuilder.ValueType.Array32BitIntSigned: var a32i = new List <int>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToInt32(DataBytes, index); index += 4; a32i.Add(ul); } return(string.Join(",", a32i)); case TagBuilder.ValueType.Array32BitIntUnsigned: var a32ui = new List <uint>(); index = 0; while (index < DataBytes.Length) { var ul = BitConverter.ToUInt32(DataBytes, index); index += 4; a32ui.Add(ul); } return(string.Join(",", a32ui)); case TagBuilder.ValueType.Array8BitIntSigned: var sb = new List <sbyte>(); index = 0; while (index < DataBytes.Length) { sb.Add((sbyte)DataBytes[index]); index += 1; } return(string.Join(",", sb)); case TagBuilder.ValueType.Array8BitIntUnsigned: var b = new List <byte>(); index = 0; while (index < DataBytes.Length) { b.Add(DataBytes[index]); index += 1; } return(string.Join(",", b)); case TagBuilder.ValueType.ArrayFloat32Bit: var sl = new List <float>(); index = 0; while (index < DataBytes.Length) { var sn = BitConverter.ToSingle(DataBytes, index); index += 4; sl.Add(sn); } return(string.Join(",", sl)); case TagBuilder.ValueType.ArrayFloat64Bit: var dl = new List <double>(); index = 0; while (index < DataBytes.Length) { var dn = BitConverter.ToDouble(DataBytes, index); index += 4; dl.Add(dn); } return(string.Join(",", dl)); case TagBuilder.ValueType.ArrayBool: var boo = new List <bool>(); index = 0; while (index < DataBytes.Length) { var bv = BitConverter.ToInt32(DataBytes, index) != 0; boo.Add(bv); index += 4; } return(string.Join(",", boo)); case TagBuilder.ValueType.ArrayFileTime: var dto = new List <string>(); index = 0; while (index < DataBytes.Length) { var ts = DateTime.FromFileTime(BitConverter.ToInt64(DataBytes, index)).ToUniversalTime(); dto.Add(ts.ToString("yyyy-MM-dd HH:mm:ss.fffffff")); index += 8; } return(string.Join(",", dto)); case TagBuilder.ValueType.ArraySystemTime: var st = new List <string>(); index = 0; while (index < DataBytes.Length) { var stb = new byte[16]; Buffer.BlockCopy(DataBytes, index, stb, 0, 16); index += 16; var nst = GetSystemTime(stb).ToUniversalTime(); st.Add(nst.ToString("yyyy-MM-dd HH:mm:ss.fffffff")); } return(string.Join(",", st)); case TagBuilder.ValueType.ArrayGuid: var gl = new List <string>(); index = 0; while (index < DataBytes.Length) { var gb = new byte[16]; Buffer.BlockCopy(DataBytes, index, gb, 0, 16); index += 16; var ng = new Guid(gb); gl.Add(ng.ToString()); } return(string.Join(",", gl)); case TagBuilder.ValueType.ArraySizeType: case TagBuilder.ValueType.ArraySids: case TagBuilder.ValueType.Array32BitHex: case TagBuilder.ValueType.Array64BitHex: default: throw new ArgumentOutOfRangeException( $"When converting substitution array entry to string, ran into unknown Value type: {ValType}. Please submit to [email protected]!"); } }
public async Task WriterHeaderIntroTocAsync_ValidData_Written() { var toc = new Nefs20HeaderIntroToc(); toc.Data0x04_OffsetToPart1.Value = 111; toc.Data0x0c_OffsetToPart2.Value = 222; toc.Data0x14_OffsetToPart3.Value = 333; toc.Data0x18_OffsetToPart4.Value = 444; toc.Data0x1c_OffsetToPart5.Value = 555; toc.Data0x08_OffsetToPart6.Value = 666; toc.Data0x10_OffsetToPart7.Value = 777; toc.Data0x20_OffsetToPart8.Value = 888; toc.Data0x00_NumVolumes.Value = 404; toc.Data0x02_HashBlockSize.Value = 505; // This chunk of data is unknown, but it must be 0x5C bytes long toc.Data0x24_Unknown.Value = new byte[0x5C]; toc.Data0x24_Unknown.Value[0] = 20; /* * Write */ var writer = this.CreateWriter(); byte[] buffer; var offset = 10; using (var ms = new MemoryStream()) { await writer.WriteHeaderIntroTocAsync(ms, (uint)offset, toc, new NefsProgress()); buffer = ms.ToArray(); } /* * Verify */ // Num volumes Assert.Equal(404, BitConverter.ToInt16(buffer, offset + 0x00)); // Hash block size Assert.Equal(505, BitConverter.ToInt16(buffer, offset + 0x02)); // Offset to part 1 Assert.Equal(111, BitConverter.ToInt32(buffer, offset + 0x04)); // Offset to part 6 Assert.Equal(666, BitConverter.ToInt32(buffer, offset + 0x08)); // Offset to part 2 Assert.Equal(222, BitConverter.ToInt32(buffer, offset + 0x0C)); // Offset to part 7 Assert.Equal(777, BitConverter.ToInt32(buffer, offset + 0x10)); // Offset to part 3 Assert.Equal(333, BitConverter.ToInt32(buffer, offset + 0x14)); // Offset to part 4 Assert.Equal(444, BitConverter.ToInt32(buffer, offset + 0x18)); // Offset to part 5 Assert.Equal(555, BitConverter.ToInt32(buffer, offset + 0x1C)); // Offset to part 8 Assert.Equal(888, BitConverter.ToInt32(buffer, offset + 0x20)); // 0x24 Unknown Assert.Equal(20, buffer[offset + 0x24]); }
public void Update() { if (socket_status == NetSocket.CLOSE) { return; } if (socket.Status == NetSocket.DISCONNECT) { event_close(); socket_status = NetSocket.DISCONNECT; Debug.Log("[NetProtocol] Reconnect addr " + connect_addr + ":" + connect_port); socket.Connect(connect_addr, connect_port); } switch (socket_status) { case NetSocket.DISCONNECT: if (socket.Status == NetSocket.CONNECTED) { socket_status = NetSocket.CONNECTED; event_connect(); } break; } if (socket.Length < 2) { return; } if (length_val == 0) { socket.Read(buffer, 2); length_val = BitConverter.ToInt16(buffer, 0); length_val = System.Net.IPAddress.NetworkToHostOrder(length_val); } if (socket.Length < length_val) { return; } if (buffer.Length < length_val) { buffer = new byte[length_val]; } socket.Read(buffer, 4); int cmd = BitConverter.ToInt32(buffer, 0); Debug.Assert(length_val > 4); length_val -= sizeof(int); socket.Read(buffer, length_val); if (!protocol_obj.ContainsKey(cmd)) { Debug.Log("[NetProtocol] can't has handler of cmd[" + cmd + "]"); return; } wire obj = protocol_obj[cmd]; int err = obj._parse(buffer, length_val); length_val = 0; //Debug.Log("[NetProtocol] Process cmd[" + obj._name() + "]Err:" + err); if (err < 0) { return; } cb_t cb = protocol_cb[cmd]; cb(0, obj); return; }
static bool DecodeArrayInitializer(TypeSig elementTypeRef, byte[] initialValue, ILExpression[] output) { TypeCode elementType = TypeAnalysis.GetTypeCode(elementTypeRef); switch (elementType) { case TypeCode.Boolean: case TypeCode.Byte: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)d[i])); case TypeCode.SByte: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)unchecked ((sbyte)d[i]))); case TypeCode.Int16: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToInt16(d, i))); case TypeCode.Char: case TypeCode.UInt16: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToUInt16(d, i))); case TypeCode.Int32: case TypeCode.UInt32: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt32)); case TypeCode.Int64: case TypeCode.UInt64: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt64)); case TypeCode.Single: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToSingle)); case TypeCode.Double: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToDouble)); case TypeCode.Object: var typeDef = elementTypeRef.ToTypeDefOrRef().ResolveWithinSameModule(); if (typeDef != null && typeDef.IsEnum) { return(DecodeArrayInitializer(typeDef.GetEnumUnderlyingType(), initialValue, output)); } return(false); default: return(false); } }
public short rdShort(bool AddToImageAddress, int pOffset) { return(BitConverter.ToInt16(this.rdMem(pOffset, 2, AddToImageAddress), 0)); }