private QueryResult GetMemoryRegionInfos()
{
byte[] packet = GenerateEmptyPacketData();
packet[1] = 0x02; // query
if (!UsbConn.WritePacket(packet))
{
return(null);
}
packet = UsbConn.ReadPacket();
if (null == packet)
{
return(null);
}
var result = new QueryResult {
BytesPerPacket = packet[2]
};
for (int i = 0; i < QueryResult.MaxRegions; i++)
{
var typeFlag = packet[4 + (i * 9)];
if (0xff == typeFlag)
{
break;
}
result.Add(new MemoryRegionInfo(
typeFlag,
BitConverter.ToUInt32(packet, 5 + (i * 9)),
BitConverter.ToUInt32(packet, 9 + (i * 9))
));
}
return(result);
}
private DaqStatusValues QueryStatus()
{
var status = DaqStatusValues.Default;
using (IsolateConnection()) {
System.Diagnostics.Debug.Write("Status");
ConnectIfRequired();
var queryPacket = GenerateQueryDaqStatusPacketData();
if (null != UsbConn && UsbConn.WritePacket(queryPacket))
{
queryPacket = UsbConn.ReadPacket(QuarterSecond);
if (null != queryPacket)
{
var volUsbRaw = (ushort)(queryPacket[2] | (queryPacket[3] << 8));
var volBatRaw = (ushort)(queryPacket[4] | (queryPacket[5] << 8));
var tmpDaqRaw = (ushort)(queryPacket[7] | (queryPacket[6] << 8));
var temp = (tmpDaqRaw / 10.0) - 40.0;
var volUsb = (volUsbRaw / 1024.0) * 6.4;
var volBat = (volBatRaw / 1024.0) * 6.4;
status = new DaqStatusValues(volBat, volUsb, temp);
System.Diagnostics.Debug.WriteLine(": " + status);
}
}
if (status == DaqStatusValues.Default)
{
System.Diagnostics.Debug.WriteLine(": FAIL!");
}
}
return(status);
}
public bool Reboot()
{
byte[] packet = GenerateEmptyPacketData();
packet[1] = 0x08;
bool ok = UsbConn.WritePacket(packet);
ok |= UsbConn.WritePacket(packet);
System.Threading.Thread.Sleep(100);
ok |= UsbConn.WritePacket(packet);
return(ok);
}
public void SetNetworkSize(int size)
{
using (NewQueryPause()) {
using (IsolateConnection()) {
System.Diagnostics.Debug.Write("SetSize");
ConnectIfRequired();
var queryPacket = GenerateNetworkSizePacketData(0xff, 0xff, size);
if (UsbConn.WritePacket(queryPacket))
{
_networkSize = size;
}
System.Diagnostics.Debug.WriteLine(": OK");
}
}
}
private bool EraseDevice()
{
var packet = GenerateEmptyPacketData();
packet[1] = 0x04;
if (!UsbConn.WritePacket(packet))
{
return(false);
}
ClearPacket(packet);
packet[1] = 0x02;
UsbConn.WritePacket(packet);
packet = UsbConn.ReadPacket();
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);
}
private bool WritePacket(byte[] packet)
{
return(null != UsbConn && UsbConn.WritePacket(packet));
}
