public void ReadPage(byte[] data, int dataStart, int dataLength, AvrMemoryType memType) { WriteCommand(StkV1Command.ReadPage); WriteByte((byte)(dataLength >> 8)); WriteByte((byte)(dataLength & 0xff)); switch (memType) { case AvrMemoryType.Flash: WriteChar('F'); break; case AvrMemoryType.Eeprom: WriteChar('E'); break; default: throw new NotSupportedException(); } WriteCrcEop(); AssertInSync(); for (var i = 0; i < dataLength; i++) { data[i + dataStart] = _port.ReceiveByte(); } AssertOk(); }
public void WritePage(int address, AvrMemoryType memType, byte[] data, int dataStart, int dataLength) { for (var i = 0; i < dataLength; i++) { switch (memType) { case AvrMemoryType.Flash: _client.LoadProgramMemoryPageByte((ushort)(address + i), data[i + dataStart]); break; case AvrMemoryType.Eeprom: _client.WriteEepromMemory((ushort)(address + i), data[i + dataStart]); break; case AvrMemoryType.FuseBits: WriteFuseByte(address + i, data[i + dataStart]); break; case AvrMemoryType.LockBits: WriteLockByte(address + i, data[i + dataStart]); break; } } if (memType == AvrMemoryType.Flash) { _client.WriteProgramMemoryPage((ushort)address); } }
public void WritePage(int address, AvrMemoryType memType, byte[] data, int dataStart, int dataLength) { switch (memType) { case AvrMemoryType.Eeprom: WriteEeprom(address, data, dataStart, dataLength); break; case AvrMemoryType.Flash: WriteFlash(address, data, dataStart, dataLength); break; case AvrMemoryType.LockBits: for (var i = 0; i < dataLength; i++) { WriteLockByte(address + i, data[i + dataStart]); } break; case AvrMemoryType.FuseBits: for (var i = 0; i < dataLength; i++) { WriteFuseByte(address + i, data[i + dataStart]); } break; default: throw new NotSupportedException(); } }
public void WritePage(int address, AvrMemoryType memType, byte[] data, int dataStart, int dataLength) { Thread.Sleep(50); var mem = GetMemory(memType); for (var i = 0; i < dataLength; i++) { mem[(i + address) % mem.Length] = data[i + dataStart]; } }
private static bool VerifyBlocks(IProgrammer programmer, HexBlocks blocks, AvrMemoryType memType, DeviceOperation op) { if (blocks.Blocks.All(block => VerifyBlock(programmer, block, memType, op))) { return(true); } op.Complete(); op.Status = DeviceOperationStatus.Error; return(false); }
public bool Verify(AvrMemoryType memType, int address, byte value1, byte value2) { foreach (var mask in Masks) { var ch1 = mask.Process(address, memType, ref value1); var ch2 = mask.Process(address, memType, ref value2); if (ch1 || ch2) { return(value1 == value2); } } return(value1 == value2); }
public bool Process(int address, AvrMemoryType memType, ref byte bt) { if (memType != MemoryType) { return(false); } if (address < AddressStart) { return(false); } if (AddressEnd.HasValue) { if (address > AddressEnd.Value) { return(false); } } else { if (address > (AddressStart + WordSize - 1)) { return(false); } } switch (WordSize) { case 1: bt = (byte)(bt & Mask); return(true); case 2: if ((address & 0x01) == 0) { bt = (byte)(bt & Mask); } else { bt = (byte)(bt & Mask >> 8); } return(true); default: return(false); } }
private static bool VerifyBlock(IProgrammer programmer, HexBlock block, AvrMemoryType memType, DeviceOperation op) { var actualData = new byte[block.Data.Length]; programmer.ReadPage(block.Address, memType, actualData, 0, actualData.Length); for (var i = 0; i < block.Data.Length; i++) { var actual = actualData[i]; var expected = block.Data[i]; var address = i + block.Address; if (!op.Device.Verify(memType, address, actual, expected)) { op.CurrentState = string.Format("Verification failed at {0}:0x{1:x4}.\r\nExpected 0x{2:x2} but was 0x{3:x2}", memType, i + block.Address, expected, actual); return(false); } } return(true); }
private byte[] GetMemory(AvrMemoryType memType) { switch (memType) { case AvrMemoryType.Flash: return(_flash); case AvrMemoryType.Eeprom: return(_eeprom); case AvrMemoryType.FuseBits: return(_fuses); case AvrMemoryType.LockBits: return(_locks); default: throw new NotImplementedException(); } }
public void WritePage(int address, AvrMemoryType memType, byte[] data, int dataStart, int dataLength) { var offset = address; var end = address + dataLength; while (offset < end) { var cnt = Math.Min(end - offset, BLOCK_SIZE); _deviceOperation.CurrentState = string.Format("Writing {0} memory {1}-{2}", memType, offset, offset + cnt - 1); _inner.WritePage(offset, memType, data, offset - address + dataStart, cnt); offset += cnt; _deviceOperation.IncrementDone(cnt, memType); if (_deviceOperation.CancellationToken.IsCancellationRequested) { _deviceOperation.CurrentState = "Operation is cancelled"; } _deviceOperation.CancellationToken.ThrowIfCancellationRequested(); } }
public void IncrementDone(int count, AvrMemoryType memType) { switch (memType) { case AvrMemoryType.Flash: FlashDone += count; break; case AvrMemoryType.Eeprom: EepromDone += count; break; case AvrMemoryType.LockBits: LocksDone += count; break; case AvrMemoryType.FuseBits: FusesDone += count; break; } }
public void ReadPage(int address, AvrMemoryType memType, byte[] data, int dataStart, int dataLength) { for (var i = 0; i < dataLength; i++) { switch (memType) { case AvrMemoryType.Flash: data[i + dataStart] = _client.ReadFlashByte((ushort)(address + i)); break; case AvrMemoryType.Eeprom: data[i + dataStart] = _client.ReadEepromMemory((ushort)(address + i)); break; case AvrMemoryType.LockBits: data[i + dataStart] = ReadLockByte(address + i); break; case AvrMemoryType.FuseBits: data[i + dataStart] = ReadFuseByte(address + i); break; } } }