public void CastTest() { ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.Value, addr); Assert.AreEqual(addr.Value, _context.BaseAddress); }
public async Task <bool> GetRunningStateAsync(ModuleAddress module, ModuleChannel channel) { byte[] requset; if (channel == ModuleChannel.CH1) { requset = MakeRetriveDataFrame((byte)module, RetrieveCommand.GetCh1Control); } else if (channel == ModuleChannel.CH2) { requset = MakeRetriveDataFrame((byte)module, RetrieveCommand.GetCh2Control); } else { throw new InvalidOperationException(); } var response = await _commDriver.SendByteAsync(requset); var address = response[AddressFieldIndex]; var functionCode = response[FunctionFieldIndex]; // Error Check if ((functionCode & ErrorFlag) == 1) { var errorCode = (ErrorCodes)response[3]; throw new Exception($"Error Code: {errorCode.ToString()}"); } else { var isRunning = ExtractDataFromDataFrame(response) == 0; return(isRunning); } }
public void ConversionTest() { Assert.AreEqual(ModuleAddress.FromImageAddress(_context, _context.ImageBaseAddress), _context.BaseAddress); Assert.AreEqual(ModuleAddress.ToImageAddress(_context, _context.BaseAddress), _context.ImageBaseAddress); ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.ToImageAddress(), _context.ImageBaseAddress); }
public void End() { var start = new ModuleAddress(0x70); var segment = new DataSegment(start, new byte[0x20]); Assert.AreEqual(new ModuleAddress(0x110), segment.End); }
public void ConversionTest() { Assert.AreEqual(ModuleAddress.FromImageAddress(_context, _context.ImageBaseAddress), _context.BaseAddress); Assert.AreEqual(ModuleAddress.ToImageAddress(_context, _context.BaseAddress), _context.ImageBaseAddress); ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.ToImageAddress(), _context.ImageBaseAddress); }
private async Task <DataSegment> LoadSegment(ModuleAddress address, int size, CancellationToken token) { var timerToken = new CancellationTokenSource(TimeSpan.FromSeconds(1)).Token; var effectiveToken = CancellationTokenSource.CreateLinkedTokenSource(token, timerToken).Token; var data = await device.RequestDataAsync(address.DisplayValue, size, effectiveToken); return(new DataSegment(address, data)); }
public void GetData_Simple() { var start = new ModuleAddress(0x10); var segment = new DataSegment(start, new byte[] { 1, 2, 3 }); Assert.AreEqual(1, segment[start]); Assert.AreEqual(2, segment[start + 1]); Assert.AreEqual(3, segment[start + 2]); }
private void Research(GameProcess game) { ModuleAddress fmodPatchAddress = new DefaultDictionary <GameVersion, ModuleAddress>(game.Version) { [GameVersion.Alpha] = ModuleAddress.FromImageAddress(game.ModuleContext, 0x140DA75), [GameVersion.Latest] = ModuleAddress.FromImageAddress(game.ModuleContext, 0xFAA9E5) }; game.Memory.WriteByte(fmodPatchAddress, 0x2); }
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client) { var schema = ModuleSchema.KnownSchemas[ModuleIdentifier.AE10].Value; var instrumentField = schema.PhysicalRoot.ResolveField("TemporaryStudioSet/Part[1]/Instrument"); var instrumentDataField = new EnumDataField((EnumField)instrumentField); // Presets client.SendData(0x01_00_00_05, new byte[] { 64 }); for (int i = 1; i <= 128; i++) { await ShowStudioSet('P', i); } // Preset 129 is in a different bank... client.SendData(0x01_00_00_05, new byte[] { 65 }); for (int i = 129; i <= 129; i++) { await ShowStudioSet('P', i); } // User sets client.SendData(0x01_00_00_05, new byte[] { 0 }); for (int i = 1; i <= 100; i++) { await ShowStudioSet('U', i); } async Task ShowStudioSet(char prefix, int index) { client.SendData(0x01_00_00_06, new byte[] { (byte)((index - 1) & 0x7f) }); await Task.Delay(50); var common = await client.RequestDataAsync(0x18_00_00_00, 16, CancellationToken.None); string name = Encoding.UTF8.GetString(common); console.WriteLine($"{prefix}:{index:D3}: {name}"); for (int partIndex = 0; partIndex < 4; partIndex++) { var part = await client.RequestDataAsync(0x18_00_20_00 + partIndex * 0x1_00, 9, CancellationToken.None); if (part[1] != 1) { continue; } // The address doesn't matter, as only the offset is passed. var segment = new DataSegment(ModuleAddress.FromDisplayValue(0), part); instrumentDataField.Load(segment); console.WriteLine($"Part {partIndex + 1}: {instrumentDataField.Value}"); } console.WriteLine(); } return(0); }
public void GetData_7BitBoundary() { var start = new ModuleAddress(0x70); var segment = new DataSegment(start, Enumerable.Range(0, 0x20).Select(x => (byte)x).ToArray()); Assert.AreEqual(0, segment[new ModuleAddress(0x70)]); Assert.AreEqual(0xf, segment[new ModuleAddress(0x7f)]); // We skip 0x80-0xff. Assert.AreEqual(0x10, segment[new ModuleAddress(0x100)]); Assert.AreEqual(0x1f, segment[new ModuleAddress(0x10f)]); }
/// <summary> /// Creates a new snapshot with all the segments in this one, but relocated /// such that the data is <paramref name="from"/> is moved to <paramref name="to"/> /// (and all other data is offset by the same amount). /// </summary> internal ModuleDataSnapshot Relocated(ModuleAddress from, ModuleAddress to) { var offset = to.LogicalValue - from.LogicalValue; var snapshot = new ModuleDataSnapshot(); foreach (var segment in Segments) { snapshot.Add(segment.WithAddress(segment.Address.PlusLogicalOffset(offset))); } return(snapshot); }
private void btnScan_Click(object sender, EventArgs e) { txtResults.Clear(); lblStatus.ForeColor = Color.Red; byte[] patternBytes; try { patternBytes = HexStringToByteArray(txtPattern.Text.Trim()); } catch { lblStatus.Text = "Invalid pattern format."; return; } byte[] maskBytes = null; try { if (txtMask.TextLength > 0) { maskBytes = HexStringToByteArray(txtMask.Text.Trim()); } } catch { lblStatus.Text = "Invalid mask format."; return; } if (maskBytes != null && patternBytes.Length != maskBytes.Length) { lblStatus.Text = "Mask length must match pattern length when specified."; return; } // TODO: in the better implementation check for too short of a pattern, or not enough mask bits, issuing a warning that too many results may be returned var results = Scanner.SimpleScan(patternBytes, maskBytes); StringBuilder sb = new StringBuilder(); foreach (var result in results) { uint imageAddress = ModuleAddress.ToImageAddress(Game.ModuleContext, result); uint processAddress = result; sb.AppendLine(string.Format("0x{0} | 0x{1}", Convert.ToString(imageAddress, 16).ToUpperInvariant().PadLeft(8, '0'), Convert.ToString(processAddress, 16).ToUpperInvariant().PadLeft(8, '0'))); } txtResults.Text = sb.ToString(); lblStatus.ResetForeColor(); lblStatus.Text = $"{results.Count} result{(results.Count == 1 ? string.Empty : "s")} found."; }
public void Contains() { var start = new ModuleAddress(0x70); var segment = new DataSegment(start, Enumerable.Range(0, 0x20).Select(x => (byte)x).ToArray()); Assert.IsFalse(segment.Contains(new ModuleAddress(0x6f))); Assert.IsTrue(segment.Contains(new ModuleAddress(0x70))); Assert.IsTrue(segment.Contains(new ModuleAddress(0x7f))); Assert.IsTrue(segment.Contains(new ModuleAddress(0x100))); Assert.IsTrue(segment.Contains(new ModuleAddress(0x10f))); Assert.IsFalse(segment.Contains(new ModuleAddress(0x110))); }
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client) { var address = ModuleAddress.FromDisplayValue(HexInt32.Parse(context.ParseResult.ValueForOption <string>("address")).Value); var size = HexInt32.Parse(context.ParseResult.ValueForOption <string>("size")).Value; var timeout = context.ParseResult.ValueForOption <int>("timeout"); // Wait up to 10 seconds to receive all the requested data... int sizeReceived = 0; var delayTask = Task.Delay(TimeSpan.FromSeconds(timeout)); var completeTaskCts = new TaskCompletionSource <int>(); client.DataSetMessageReceived += DumpMessage; client.SendDataRequestMessage(address.DisplayValue, size); await Task.WhenAny(delayTask, completeTaskCts.Task); return(0); void DumpMessage(object sender, DataSetMessage message) { ModuleAddress address = ModuleAddress.FromDisplayValue(message.Address); console.WriteLine($"Address: {address} Length: {message.Length:x4}"); int index = 0; while (index < message.Length) { var builder = new StringBuilder(); var textBuilder = new StringBuilder(); builder.Append(address); builder.Append(" "); for (int i = 0; i < 16 && index < message.Length; i++) { byte b = message.Data[index]; textBuilder.Append(b >= 32 && b < 127 ? (char)b : ' '); builder.Append(b.ToString("x2")); builder.Append(" "); index++; } string text = builder.ToString().PadRight(9 + 16 * 3) + textBuilder; console.WriteLine(text); address = address.PlusLogicalOffset(16); } console.WriteLine(); if (Interlocked.Add(ref sizeReceived, message.Length) >= size) { completeTaskCts.SetResult(0); } } }
public void CreationTest() { ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.Context, _context); Assert.AreEqual(addr.Value, _context.BaseAddress); new ModuleAddress(_context, _context.BaseAddress + _context.Size); try { new ModuleAddress(_context, _context.BaseAddress - 1); Assert.Fail(); } catch { /* before valid range */ } try { new ModuleAddress(_context, _context.BaseAddress + _context.Size + 1); Assert.Fail(); } catch { /* past valid range */ } try { new ModuleAddressContext(0x400000, 0x700000, 0); Assert.Fail(); } catch { /* zero size */ } try { new ModuleAddressContext(uint.MaxValue - 1, 0, 10); Assert.Fail(); } catch { /* image address overflow */ } try { new ModuleAddressContext(0, uint.MaxValue - 1, 10); Assert.Fail(); } catch { /* module address overflow */ } }
public void CreationTest() { ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.Context, _context); Assert.AreEqual(addr.Value, _context.BaseAddress); new ModuleAddress(_context, _context.BaseAddress + _context.Size); try { new ModuleAddress(_context, _context.BaseAddress - 1); Assert.Fail(); } catch { /* before valid range */ } try { new ModuleAddress(_context, _context.BaseAddress + _context.Size + 1); Assert.Fail(); } catch { /* past valid range */} try { new ModuleAddressContext(0x400000, 0x700000, 0); Assert.Fail(); } catch { /* zero size */ } try { new ModuleAddressContext(uint.MaxValue - 1, 0, 10); Assert.Fail(); } catch { /* image address overflow */ } try { new ModuleAddressContext(0, uint.MaxValue - 1, 10); Assert.Fail(); } catch { /* module address overflow */ } }
internal IEnumerable <IContainer> ToContainers(ModuleSchema schema, ModuleJson module, ModuleAddress parentAddress, string?parentPath, SchemaVariables variables) { variables = variables.WithVariables(ExtraVariables); ModuleOffset offset = ModuleOffset.FromDisplayValue(Offset.Value); if (Repeat is null) { yield return(resolvedContainer.ToContainer(schema, module, ResolvedName, ResolvedDescription, parentAddress + offset, parentPath, variables)); } else { int gap = ModuleOffset.FromDisplayValue(Repeat.Gap.Value).LogicalValue; foreach (var tuple in module.GetRepeatSequence(Repeat.Items, variables)) { var itemVariables = variables.WithVariable(Repeat.IndexVariable, tuple.index, Repeat.IndexTemplate); var formattedDescription = tuple.variables.Replace(ResolvedDescription); var formattedName = Invariant($"{ResolvedName}[{tuple.index}]"); yield return(resolvedContainer.ToContainer(schema, module, formattedName, formattedDescription, parentAddress + offset, parentPath, itemVariables)); offset += gap; } } }
public DataSegment(ModuleAddress address, byte[] data) => (Address, this.data) = (address, data);
private protected ContainerBase(ModuleSchema schema, string name, string description, ModuleAddress address, string path) => (Schema, Name, Description, Address, Path) = (schema, name, description, address, path);
protected override async Task <int> InvokeAsync(InvocationContext context, IStandardStreamWriter console, RolandMidiClient client) { using var writer = File.CreateText(context.ParseResult.ValueForOption <string>("file")); int chunkSize = context.ParseResult.ValueForOption <int>("chunkSize"); TimeSpan timeout = TimeSpan.FromMilliseconds(context.ParseResult.ValueForOption <int>("timeout")); var address = ModuleAddress.FromDisplayValue(0); int messagesReceived = 0; client.DataSetMessageReceived += DumpMessage; // TODO: Make this tighter. But we're unlikely to really get here. while (address.DisplayValue < 0x74_00_00_00) { int receivedAtStartOfChunk = messagesReceived; client.SendDataRequestMessage(address.DisplayValue, chunkSize); int receivedAtStartOfDelay; do { receivedAtStartOfDelay = messagesReceived; await Task.Delay(timeout); } while (messagesReceived > receivedAtStartOfDelay); int receivedForChunk = messagesReceived - receivedAtStartOfChunk; console.WriteLine($"Received {receivedForChunk} messages in chunk at {address}"); writer.Flush(); address = address.PlusLogicalOffset(chunkSize); } return(0); void DumpMessage(object sender, DataSetMessage message) { ModuleAddress address = ModuleAddress.FromDisplayValue(message.Address); writer.WriteLine($"Address: {address} Length: {message.Length:x4}"); int index = 0; while (index < message.Length) { var builder = new StringBuilder(); var textBuilder = new StringBuilder(); builder.Append(address); builder.Append(" "); for (int i = 0; i < 16 && index < message.Length; i++) { byte b = message.Data[index]; textBuilder.Append(b >= 32 && b < 127 ? (char)b : ' '); builder.Append(b.ToString("x2")); builder.Append(" "); index++; } string text = builder.ToString().PadRight(9 + 16 * 3) + textBuilder; writer.WriteLine(text); address = address.PlusLogicalOffset(16); } writer.WriteLine(); Interlocked.Increment(ref messagesReceived); } }
public bool TryGetSegment(ModuleAddress address, out DataSegment segment) => segmentsByAddress.TryGetValue(address, out segment);
internal DataSegment this[ModuleAddress address] => segmentsByAddress[address];
public ValidationError(string path, ModuleAddress address, IField field, string message) => (Path, Address, Field, Message) = (path, address, field, message);
public void CastTest() { ModuleAddress addr = new ModuleAddress(_context, _context.BaseAddress); Assert.AreEqual(addr.Value, addr); Assert.AreEqual(addr.Value, _context.BaseAddress); }
public IContainer ToContainer(ModuleSchema schema, ModuleJson module, string name, string description, ModuleAddress address, string?parentPath, SchemaVariables variables) { string path = PathUtilities.AppendPath(parentPath, name); if (Fields is object) { var fieldList = requiresOverlayResolution ? resolvedFields.Select(FinalizeField) : resolvedFields; var realSize = ModuleOffset.FromDisplayValue(Size.Value).LogicalValue; return(new FieldContainer(schema, name, description, address, path, realSize, fieldList)); FieldBase FinalizeField(FieldBase field) => field is OverlayField overlay?overlay.WithPath(variables.Replace(overlay.SwitchPath)) : field; } else { var containers = new List <IContainer>(); foreach (var container in Containers) { containers.AddRange(container.ToContainers(schema, module, address, path, variables)); } return(new ContainerContainer(schema, name, description, address, path, containers)); } }
internal FieldContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path, int size, IEnumerable <FieldBase> fields) : base(schema, name, description, address, path) { Fields = fields.ToReadOnlyList(field => field.WithParent(this)); Size = size; fieldsByName = Lazy.Create(() => Fields.ToDictionary(f => f.Name).AsReadOnly()); }
internal FieldContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path, int size, IReadOnlyList <IField> fields) : base(schema, name, description, address, path) => (Size, Fields, FieldsByName) = (size, fields, fields.ToDictionary(f => f.Name).AsReadOnly());
public FixedContainer(Container container, ModuleAddress address) => (Container, Address) = (container, address);
internal ContainerContainer(ModuleSchema schema, string name, string description, ModuleAddress address, string path, List <IContainer> containers) : base(schema, name, description, address, path) { Containers = containers; foreach (ContainerBase container in Containers) { container.Parent = this; } ContainersByName = Containers.ToDictionary(c => c.Name).AsReadOnly(); }
internal DataSegment ToModel() => new DataSegment(ModuleAddress.FromDisplayValue(Address), Data.ToByteArray());