public bool Program(MemoryRegionDataCollection memoryRegionDataBlocks, Action <double, string> progressUpdated)
{
if (!UsbConn.IsConnected)
{
return(false);
}
if (null == progressUpdated)
{
progressUpdated = NullProgressAction;
}
progressUpdated(0, queryTaskDesciption);
QueryResult deviceMemoryRegions = GetMemoryRegionInfos();
if (null == deviceMemoryRegions || deviceMemoryRegions.Count <= 0)
{
return(false);
}
progressUpdated(0.05, eraseTaskDesciption);
EraseDevice(); // if the erase fails, we should probably keep going.
double writeBaseProgress = 0.3;
double writeTotalProgress = 1.0 - writeBaseProgress;
progressUpdated(writeBaseProgress, progTaskDesciption);
IEnumerable <MemoryRegionInfo> memoryRegions = deviceMemoryRegions.Where(mri => mri.TypeFlag != 0x03);
long totalBytes = Math.Max(memoryRegions.Sum(mr => mr.Length), 1);
long totalBytesWritten = 0;
long bytesForProgressUpdate = totalBytes / 100;
long lastProgressUpdateBytes = 0;
foreach (MemoryRegionInfo currentRegion in memoryRegions.OrderByDescending(mr => mr.TypeFlag))
{
var lastAddress = currentRegion.Address + currentRegion.Length - 1;
var packet = GenerateEmptyPacketData();
IEnumerable <MemoryRegionData> blocksForWrite = memoryRegionDataBlocks
.Where(dataBlock => dataBlock.Address >= currentRegion.Address && dataBlock.Address <= lastAddress)
.OrderBy(dataBlock => dataBlock.Address)
;
var finalAddress = blocksForWrite.Max(b => (int)b.LastAddress);
var bytes = new byte[currentRegion.Length];
var baseOffsetAddress = currentRegion.Address;
var lastLocalAddress = -1;
foreach (var block in blocksForWrite)
{
var localBlockAddress = checked ((int)(block.Address - baseOffsetAddress));
for (int i = lastLocalAddress + 1; i < localBlockAddress; i++)
{
bytes[i] = 0xff;
}
var chunk = block.Data.ToArray();
Array.Copy(chunk, 0, bytes, localBlockAddress, chunk.Length);
lastLocalAddress = (int)block.LastAddress;
}
for (int i = lastLocalAddress + 1; i < currentRegion.Length; i++)
{
bytes[i] = 0xff;
}
for (int txOffset = 0; txOffset < bytes.Length; txOffset += deviceMemoryRegions.BytesPerPacket)
{
ClearPacket(packet);
packet[1] = 0x05;
int localAddress = (int)(baseOffsetAddress + txOffset);
if (localAddress > finalAddress)
{
break;
}
Array.Copy(BitConverter.GetBytes(localAddress), 0, packet, 2, 4);
byte bytesToWrite = (
(txOffset + deviceMemoryRegions.BytesPerPacket > bytes.Length)
? (byte)(bytes.Length - txOffset)
: deviceMemoryRegions.BytesPerPacket
);
packet[6] = bytesToWrite;
//bytes.CopyTo(txOffset, packet, 7, bytesToWrite);
Array.Copy(bytes, txOffset, packet, 7, bytesToWrite);
totalBytesWritten += bytesToWrite;
if (totalBytesWritten >= lastProgressUpdateBytes + bytesForProgressUpdate)
{
lastProgressUpdateBytes = totalBytesWritten;
progressUpdated(writeBaseProgress + ((totalBytesWritten * writeTotalProgress) / (double)totalBytes), progTaskDesciption);
}
System.Diagnostics.Debug.WriteLine("Wrote@: " + (baseOffsetAddress + txOffset).ToString("X2") + ',' + bytesToWrite);
if (UsbConn.WritePacket(packet))
{
; // was OK
}
else
{
; // failed to write!
}
}
ClearPacket(packet);
packet[1] = 0x06;
UsbConn.WritePacket(packet);
}
progressUpdated(writeBaseProgress + writeTotalProgress, progTaskDesciption);
return(true);
}
public bool Program(MemoryRegionDataCollection memoryRegionDataBlocks, Action<double, string> progressUpdated)
{
if (!UsbConn.IsConnected)
return false;
if (null == progressUpdated)
progressUpdated = NullProgressAction;
progressUpdated(0, queryTaskDesciption);
QueryResult deviceMemoryRegions = GetMemoryRegionInfos();
if (null == deviceMemoryRegions || deviceMemoryRegions.Count <= 0)
return false;
progressUpdated(0.05, eraseTaskDesciption);
EraseDevice(); // if the erase fails, we should probably keep going.
double writeBaseProgress = 0.3;
double writeTotalProgress = 1.0 - writeBaseProgress;
progressUpdated(writeBaseProgress, progTaskDesciption);
IEnumerable<MemoryRegionInfo> memoryRegions = deviceMemoryRegions.Where(mri => mri.TypeFlag != 0x03);
long totalBytes = Math.Max(memoryRegions.Sum(mr => mr.Length), 1);
long totalBytesWritten = 0;
long bytesForProgressUpdate = totalBytes / 100;
long lastProgressUpdateBytes = 0;
foreach (MemoryRegionInfo currentRegion in memoryRegions.OrderByDescending(mr => mr.TypeFlag)) {
var lastAddress = currentRegion.Address + currentRegion.Length - 1;
var packet = GenerateEmptyPacketData();
IEnumerable<MemoryRegionData> blocksForWrite = memoryRegionDataBlocks
.Where(dataBlock => dataBlock.Address >= currentRegion.Address && dataBlock.Address <= lastAddress)
.OrderBy(dataBlock => dataBlock.Address)
;
var finalAddress = blocksForWrite.Max(b => (int)b.LastAddress);
var bytes = new byte[currentRegion.Length];
var baseOffsetAddress = currentRegion.Address;
var lastLocalAddress = -1;
foreach (var block in blocksForWrite) {
var localBlockAddress = checked((int)(block.Address - baseOffsetAddress));
for (int i = lastLocalAddress + 1; i < localBlockAddress; i++) {
bytes[i] = 0xff;
}
var chunk = block.Data.ToArray();
Array.Copy(chunk, 0, bytes, localBlockAddress, chunk.Length);
lastLocalAddress = (int)block.LastAddress;
}
for (int i = lastLocalAddress + 1; i < currentRegion.Length; i++)
bytes[i] = 0xff;
for (int txOffset = 0; txOffset < bytes.Length; txOffset += deviceMemoryRegions.BytesPerPacket) {
ClearPacket(packet);
packet[1] = 0x05;
int localAddress = (int)(baseOffsetAddress + txOffset);
if (localAddress > finalAddress) {
break;
}
Array.Copy(BitConverter.GetBytes(localAddress), 0, packet, 2, 4);
byte bytesToWrite = (
(txOffset + deviceMemoryRegions.BytesPerPacket > bytes.Length)
? (byte)(bytes.Length - txOffset)
: deviceMemoryRegions.BytesPerPacket
);
packet[6] = bytesToWrite;
//bytes.CopyTo(txOffset, packet, 7, bytesToWrite);
Array.Copy(bytes, txOffset, packet, 7, bytesToWrite);
totalBytesWritten += bytesToWrite;
if (totalBytesWritten >= lastProgressUpdateBytes + bytesForProgressUpdate) {
lastProgressUpdateBytes = totalBytesWritten;
progressUpdated(writeBaseProgress + ((totalBytesWritten * writeTotalProgress) / (double)totalBytes), progTaskDesciption);
}
System.Diagnostics.Debug.WriteLine("Wrote@: " + (baseOffsetAddress + txOffset).ToString("X2") + ',' + bytesToWrite);
if (UsbConn.WritePacket(packet)) {
; // was OK
}
else {
; // failed to write!
}
}
ClearPacket(packet);
packet[1] = 0x06;
UsbConn.WritePacket(packet);
}
progressUpdated(writeBaseProgress + writeTotalProgress, progTaskDesciption);
return true;
}
public bool ProgramAnemVersion2(int nid, MemoryRegionDataCollection memoryRegionDataBlocks, Action <double, string> progressUpdated)
{
if (nid < 0 || nid > 255)
{
throw new ArgumentOutOfRangeException("nid");
}
if (null == progressUpdated)
{
progressUpdated = NullAction; // so we can avoid null checks all over the place
}
using (NewQueryPause()) {
Thread.Sleep(ThreeQuarterSecond);
bool result = true;
try {
if (!UsbConn.IsConnected)
{
return(false);
}
progressUpdated(0, "Entering boot mode.");
using (IsolateConnection()) {
var anemEnterProgramMode = AnemEnterProgramModeVersion2(nid);
if (!anemEnterProgramMode)
{
progressUpdated(0, "Bad boot response.");
if (0xf != nid && 0 != nid)
{
result = false; // NOTE: if it was corrupted or unassigned, try it anyhow
}
}
Thread.Sleep(HalfSecond);
progressUpdated(0, "Writing.");
int totalBytes = memoryRegionDataBlocks.Sum(b => (int)b.Size);
int bytesSent = 0;
int lastNoticeByte = 0;
const int noticeInterval = 128;
int dotCount = 1;
if (result)
{
bool firstBlock = true;
foreach (
var block in memoryRegionDataBlocks
.Where(x => x.Address < 0x3fff && x.LastAddress > 0x800)
.OrderBy(x => x.Address)
)
{
byte[] data = block.Data.ToArray();
int checksumFails = 0;
const int maxChecksumFails = 64;
const int stride = 32;
long startIndex = 0;
if (block.Address < 0x800)
{
startIndex = 0x800 - block.Address;
}
long indexLimit = data.Length;
if (block.LastAddress > 0x3fff)
{
indexLimit = indexLimit - (block.LastAddress - 0x3fff);
}
int chunkCount = 0;
for (long i = startIndex; i < indexLimit; i += stride)
{
var bytesToWrite = Math.Min(stride, (int)(data.Length - i));
var address = i + block.Address;
var packet = GenerateEmptyPacketData(); // NOTE: length is 65 because of the first extra byte
packet[1] = 0xa1;
packet[2] = unchecked ((byte)(chunkCount % 2));
packet[3] = unchecked ((byte)(address >> 8));
packet[4] = unchecked ((byte)address);
Array.Copy(data, i, packet, 5, bytesToWrite);
byte checkSum = 0;
for (int csi = 2; csi < 37; csi++)
{
checkSum = unchecked ((byte)(checkSum + packet[csi]));
}
packet[37] = checkSum;
UsbConn.ClearPacketQueue();
if (!WritePacket(packet))
{
progressUpdated(0, "Write failure!");
result = false;
break; //return false;
}
packet = UsbConn.ReadPacket(ThreeQuarterSecond);
if (null == packet || !(packet[1] == 0xa1 && packet[2] == 0x01))
{
checksumFails++;
if (checksumFails <= (firstBlock ? 3 : maxChecksumFails))
{
i -= stride;
continue;
}
progressUpdated(0, "Checksum failure.");
result = false;
break;
}
checksumFails = 0;
bytesSent += bytesToWrite;
if ((bytesSent - lastNoticeByte) > noticeInterval)
{
lastNoticeByte = bytesSent;
dotCount++;
if (dotCount > 3)
{
dotCount = 1;
}
progressUpdated(
bytesSent / (double)(totalBytes),
String.Concat("Writing", new String(Enumerable.Repeat('.', dotCount).ToArray()))
);
}
chunkCount++;
}
firstBlock = false;
}
}
}
}
catch (Exception ex) {
progressUpdated(0, ex.ToString());
result = false;
}
finally {
var resetOk = AnemResetVersion2(nid);
if (!resetOk)
{
progressUpdated(0, "Anem reboot failure.");
}
result &= resetOk;
}
return(result);
}
}
