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;
}
}
}
