private void daqUpdateFileChooser_Click(object sender, EventArgs e)
{
var openFile = new OpenFileDialog();
openFile.AutoUpgradeEnabled = true;
openFile.DefaultExt = "hex";
openFile.Filter = "Hex memory files (*.hex)|*.hex";
openFile.SupportMultiDottedExtensions = true;
openFile.Multiselect = false;
if (DialogResult.OK != openFile.ShowDialog())
{
return;
}
var fileInfo = new FileInfo(openFile.FileName);
try {
_patchData = HexParser.ParseToMemoryRegions(
new StreamReader(
File.OpenRead(fileInfo.FullName)
)
);
daqFileLabel.Text = String.Concat("Loaded: ", fileInfo.Name);
beginDaqUpdate.Enabled = true;
}
catch (Exception ex) {
daqFileLabel.Text = String.Concat("Load error: ", ex.ToString());
Log.Error("DAQ firmware load error.", ex);
beginDaqUpdate.Enabled = false;
}
}
private void anemUpdateFileChooser_Click(object sender, EventArgs e)
{
var openFile = new OpenFileDialog();
openFile.AutoUpgradeEnabled = true;
openFile.DefaultExt = "hex";
openFile.Filter = "Hex memory files (*.hex)|*.hex";
openFile.SupportMultiDottedExtensions = true;
openFile.Multiselect = false;
if (DialogResult.OK == openFile.ShowDialog()) {
FileInfo fileInfo = new FileInfo(openFile.FileName);
try {
_anemPatchData = HexParser.ParseToMemoryRegions(
new StreamReader(
File.OpenRead(fileInfo.FullName)
)
);
anemFileLabel.Text = String.Concat("Loaded: ", fileInfo.Name);
}
catch (Exception ex) {
_anemPatchData = null;
Log.Error("Anem firmware load error.", ex);
anemFileLabel.Text = String.Concat("Load error: ", ex.ToString());
}
}
RefreshAnemUpdateEnabled();
}
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);
}
protected override bool ProgramAnem(int nid, MemoryRegionDataCollection memoryRegionDataBlocks, Action <double, string> progressUpdated)
{
return(Device.ProgramAnemVersion2(nid, memoryRegionDataBlocks, progressUpdated));
}
protected override bool ProgramAnem(int nid, MemoryRegionDataCollection memoryRegionDataBlocks, Action<double, string> progressUpdated)
{
return Device.ProgramAnemVersion2(nid, memoryRegionDataBlocks, progressUpdated);
}
public static MemoryRegionDataCollection ParseToMemoryRegions(TextReader reader)
{
string currentLine = null;
long currentExtendedOffset = 0;
bool eofReached = false;
var memoryRegions = new MemoryRegionDataCollection();
while (!String.IsNullOrEmpty(currentLine = reader.ReadLine())) {
if (currentLine[0] != ':') {
throw new InvalidDataException("Hex line does not begin with ':'. File is invalid or corrupted.");
}
byte recordType = Convert.ToByte(currentLine.Substring(7, 2), 16);
if (recordType == 0x04 || recordType == 0x00) {
byte recordLength = Convert.ToByte(currentLine.Substring(1, 2), 16);
ushort address = Convert.ToUInt16(currentLine.Substring(3, 4), 16);
uint checkSum = (uint)(recordLength + (address & 0xff) + (0xff & (address >> 8)) + recordType);
byte[] data = new byte[recordLength];
for (int i = 0; i < data.Length; i++) {
byte value = Convert.ToByte(currentLine.Substring(9 + (2 * i), 2), 16);
checkSum += value;
data[i] = value;
}
checkSum = ~checkSum + 1;
byte expectedCheckSum = Convert.ToByte(currentLine.Substring(9 + (data.Length * 2), 2), 16);
if (expectedCheckSum != (checkSum & 0xff)) {
throw new InvalidDataException("Checksum mismatch. File is invalid or corrupted.");
}
if (recordType == 0x04) {
currentExtendedOffset = ((long)BitConverter.ToUInt16(data, 0) << 16);
}
else {
long chunkAddress = currentExtendedOffset + address;
memoryRegions.Union(chunkAddress, data);
}
}
else if (recordType == 0x01) {
eofReached = true;
byte recordLength = Convert.ToByte(currentLine.Substring(1, 2), 16);
ushort address = Convert.ToUInt16(currentLine.Substring(3, 4), 16);
byte expectedCheckSum = Convert.ToByte(currentLine.Substring(9, 2), 16);
if (recordLength != 0 || address != 0 || expectedCheckSum != 0xff) {
throw new InvalidDataException("Hex EOF corrupted.");
}
break;
}
else {
;//throw new NotSupportedException(String.Concat("Hex parser does not support records of type 0x", recordType.ToString("X2")));
}
}
if (!eofReached) {
throw new InvalidDataException("No EOF record found. Hex data may be invalid or corrupted.");
}
return memoryRegions;
}
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);
}
}
public bool ProgramAnem(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 anemBootResult = AnemEnterBootMode(nid);
if (!anemBootResult)
{
progressUpdated(0, "Bad boot response.");
if (0xff != nid)
{
result = false;
}
}
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)
{
byte[] data = block.Data.ToArray();
int checksumFails = 0;
const int maxChecksumFails = 64;
const int stride = 32;
for (int i = 0; i < data.Length; i += stride)
{
int bytesToWrite = Math.Min(32, data.Length - i);
int address = i + (int)block.Address;
var packet = GenerateEmptyPacketData();
packet[1] = 0x75;
packet[2] = checked ((byte)nid);
Array.Copy(BitConverter.GetBytes(address).Reverse().ToArray(), 0, packet, 3, 4);
packet[7] = (byte)bytesToWrite;
byte checkSum = data[i];
int endIndex = i + bytesToWrite;
for (int csi = i + 1; csi < endIndex; csi++)
{
checkSum = unchecked ((byte)(checkSum + data[csi]));
}
packet[8] = checkSum;
Array.Copy(data, i, packet, 9, bytesToWrite);
UsbConn.ClearPacketQueue();
if (!WritePacket(packet))
{
progressUpdated(0, "Write failure!");
result = false;
break; //return false;
}
packet = UsbConn.ReadPacket(ThreeQuarterSecond);
if (null == packet || packet[3] != checkSum)
{
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()))
);
}
}
firstBlock = false;
}
}
}
}
catch (Exception ex) {
progressUpdated(0, ex.ToString());
result = false;
}
finally {
var resetOk = AnemReset(nid);
if (!resetOk)
{
progressUpdated(0, "Anem reboot failure.");
}
result &= resetOk;
}
return(result);
}
}
