559 lines
20 KiB
C#
559 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using DTS.Common.ICommunication;
|
|
|
|
namespace DTS.DASLib.Command.SLICE
|
|
{
|
|
public abstract class FirmwareUpdateCommands : CommandBase
|
|
{
|
|
protected enum Commands
|
|
{
|
|
Reserved = 0x00,
|
|
QueryFirmwareUpdateBlockSize = 0x01,
|
|
QueryBootloaderVersion = 0x02,
|
|
SwitchToFirmwareUpdateMode = 0x03,
|
|
BeginFirmwareUpdate = 0x04,
|
|
ProgramFirmwareUpdateBlock = 0x05,
|
|
FinishFirmwareUpdate = 0x06,
|
|
Reboot = 0x07,
|
|
QueryInFirmwareUpdateMode = 0x08,
|
|
|
|
// added to support slice pro (Bridge/IEPE) firmware update via USB.
|
|
Load_SliceProStackFirmwareImage = 0x09, // CMDFW_LOAD_STACK_FW, // = 0x09, loading (in 400-byte blocks) firmware image to base NAND.
|
|
Query_SliceProStackFirmwareImage = 0x0A, // CMDFW_QUERY_STACK_FW, // = 0x0A, reading block (in 400-byte blocks) of firmware image from base NAND at a time.
|
|
Query_SliceProStackFirmwareCRC = 0x0B, // CMDFW_QUERY_STACK_FW_CRC, // = 0x0B, read firmware CRC for validation purpose.
|
|
Start_SliceProStackFirmwareUpdate = 0x0C, // CMDFW_START_STACK_FW_UPDADE, // = 0x0C, stack module to be upgraded with firmware.
|
|
Stop_SliceProStackFirmwareUpdate = 0x0D, // CMDFW_STOP_STACK_FW_UPDADE, // = 0x0D, stop firmware upgrade for after completes the on-going one.
|
|
Query_SliceProStackFirmwareUpdateMode = 0x0E, // CMDFW_QUERY_STACK_FW_UPDATE_MODE, // = 0x0E, polling updatae mode from stack
|
|
Set_SliceProStackFirmwareUpdateMode = 0x0F, // CMDFW_SET_STACK_FW_UPDATE_MODE, // = 0x0F, Set stack module to update mode
|
|
MAX_CMDFW_COMMAND // = 0x10
|
|
};
|
|
|
|
public enum FirmwareMode
|
|
{
|
|
FW = 0,
|
|
BL = 1,
|
|
BLL = 2,
|
|
};
|
|
|
|
//protected const int MIN_SLICE2_FILEDATA_PROTOCOL = 130; //SLICE 2 Protocol cmd
|
|
protected const int MAX_FILE_ID = 30; // user = 10, firmware = 20, max internally = 65. 10;
|
|
protected const int MAX_FILE_LENGTH = 400;
|
|
|
|
protected abstract Commands _Command { get; }
|
|
protected FirmwareUpdateCommands(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
protected FirmwareUpdateCommands(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
}
|
|
|
|
public class QueryFirmwareUpdateBlockSize : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.QueryFirmwareUpdateBlockSize;
|
|
|
|
private ushort _size;
|
|
public ushort BlockSize => _size;
|
|
|
|
public QueryFirmwareUpdateBlockSize(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
_size = 0;
|
|
}
|
|
|
|
public QueryFirmwareUpdateBlockSize(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
_size = 0;
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
response.GetParameter(0, out _size);
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
$"BlockSize: {BlockSize}"
|
|
});
|
|
}
|
|
}
|
|
|
|
public class QueryBootloaderVersion : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.QueryBootloaderVersion;
|
|
|
|
private string _version = string.Empty;
|
|
public string Version => _version;
|
|
|
|
public QueryBootloaderVersion(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public QueryBootloaderVersion(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
response.GetParameter(0, out _version);
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
$"Version: {Version}"
|
|
});
|
|
}
|
|
}
|
|
|
|
public class SwitchToFirmwareUpdateMode : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.SwitchToFirmwareUpdateMode;
|
|
|
|
public SwitchToFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public SwitchToFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class BeginFirmwareUpdate : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.BeginFirmwareUpdate;
|
|
|
|
public BeginFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public BeginFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class ProgramFirmwareUpdateBlock : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.ProgramFirmwareUpdateBlock;
|
|
|
|
private uint _address;
|
|
private ushort _blockcrc;
|
|
private ushort _upperlower;
|
|
private byte[] _data;
|
|
|
|
public uint BlockBaseAddress
|
|
{
|
|
get => _address;
|
|
set
|
|
{
|
|
_address = value;
|
|
command.SetParameter(0, _address);
|
|
}
|
|
}
|
|
|
|
public ushort BlockSize { get; private set; }
|
|
|
|
public ushort BlockCRC16
|
|
{
|
|
get => _blockcrc;
|
|
set
|
|
{
|
|
_blockcrc = value;
|
|
command.SetParameter(6, _blockcrc);
|
|
}
|
|
}
|
|
|
|
public bool Upper
|
|
{
|
|
get => _upperlower == 1 ? true : false;
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
_upperlower = 1;
|
|
command.SetParameter(8, _upperlower);
|
|
}
|
|
}
|
|
}
|
|
|
|
public byte[] Data
|
|
{
|
|
get => _data;
|
|
set
|
|
{
|
|
if (null == value)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_data = value;
|
|
if (command.Parameter.Length < value.Length + 10)
|
|
{
|
|
var newparameter = new byte[value.Length + 10];
|
|
BlockSize = (ushort)value.Length;
|
|
command.SetParameter(4, BlockSize);
|
|
Buffer.BlockCopy(command.Parameter, 0,
|
|
newparameter, 0, 10);
|
|
command.Parameter = newparameter;
|
|
Buffer.BlockCopy(_data, 0, command.Parameter, 10, _data.Length);
|
|
}
|
|
}
|
|
}
|
|
|
|
public ProgramFirmwareUpdateBlock(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Parameter = new byte[10];
|
|
Upper = false;
|
|
}
|
|
|
|
public ProgramFirmwareUpdateBlock(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Parameter = new byte[10];
|
|
Upper = false;
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { $"BlockBaseAddress: {BlockBaseAddress}, BlockSize: {BlockSize}, BlockCRC16: {BlockCRC16}, Upper: {Upper}" });
|
|
}
|
|
}
|
|
|
|
public class FinishFirmwareUpdate : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.FinishFirmwareUpdate;
|
|
|
|
private ushort _imagecrc;
|
|
|
|
public ushort ImageCRC16
|
|
{
|
|
get => _imagecrc;
|
|
set
|
|
{
|
|
_imagecrc = value;
|
|
command.SetParameter(0, _imagecrc);
|
|
}
|
|
}
|
|
|
|
public FinishFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Parameter = new byte[2];
|
|
}
|
|
|
|
public FinishFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Parameter = new byte[2];
|
|
}
|
|
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
base.CommandToString(ref lines);
|
|
lines.Add(new List<string>() { $"ImageCRC16: {ImageCRC16}" });
|
|
}
|
|
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
$"ImageCRC16: {ImageCRC16}"
|
|
});
|
|
}
|
|
}
|
|
|
|
public class Reboot : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.Reboot;
|
|
public Reboot(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public Reboot(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
}
|
|
|
|
public class QueryInFirmwareUpdateMode : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.QueryInFirmwareUpdateMode;
|
|
private byte _updateMode = (byte)FirmwareMode.FW;
|
|
public bool InUpdateMode => FirmwareMode.FW != (FirmwareMode)_updateMode;
|
|
|
|
public bool IsFwMode => FirmwareMode.FW == (FirmwareMode)_updateMode;
|
|
public bool IsBlMode => FirmwareMode.BL == (FirmwareMode)_updateMode;
|
|
public bool IsBllMode => FirmwareMode.BLL == (FirmwareMode)_updateMode;
|
|
|
|
public FirmwareMode Mode => (FirmwareMode)_updateMode;
|
|
|
|
public QueryInFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
}
|
|
|
|
public QueryInFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
}
|
|
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
response.GetParameter(0, out _updateMode);
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
public override void ResponseToString(ref List<List<string>> lines)
|
|
{
|
|
base.ResponseToString(ref lines);
|
|
lines.Add(new List<string>()
|
|
{
|
|
string.Format($"UpdateMode: {(FirmwareMode)_updateMode}")
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
///These stack firmware command updates need at least protocol version 137
|
|
///No parameter. All slice in bootloader mode will be updated with new firmware.
|
|
/// </summary>
|
|
///
|
|
public class Load_SliceProStackFirmwareImage : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.Load_SliceProStackFirmwareImage;
|
|
|
|
#region Private Variables
|
|
private readonly ushort _fileID; //Byte 0-1: 16-bit file ID ranges from 1-10.
|
|
private uint _startByteCount;
|
|
private byte[] _data;
|
|
private static byte PARAM_NUM = 6;
|
|
#endregion
|
|
|
|
#region Command Parameters
|
|
|
|
public uint StartByteCount
|
|
{
|
|
get => _startByteCount;
|
|
set { _startByteCount = value; command.SetParameter(2, _startByteCount); }
|
|
}
|
|
|
|
public byte[] Data
|
|
{
|
|
get => _data;
|
|
set
|
|
{
|
|
if (null == value)
|
|
{
|
|
return;
|
|
}
|
|
if (MAX_FILE_LENGTH < value.Length)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
_data = value;
|
|
//if (this.command.Parameter.Length < value.Length+ PARAM_NUM)
|
|
//{
|
|
byte[] newparameter = new byte[value.Length + PARAM_NUM];
|
|
Buffer.BlockCopy(command.Parameter, 0, newparameter, 0, PARAM_NUM);
|
|
Size = value.Length;
|
|
command.Parameter = newparameter;
|
|
Buffer.BlockCopy(_data, 0, command.Parameter, PARAM_NUM, _data.Length);
|
|
//}
|
|
}
|
|
}
|
|
|
|
public int Size { get; private set; }
|
|
|
|
public int MaximumFileStreamBytes => MAX_FILE_LENGTH;
|
|
|
|
#endregion
|
|
|
|
#region Command Functions
|
|
public Load_SliceProStackFirmwareImage(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
command.Parameter = new byte[PARAM_NUM];
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
_data = null;
|
|
|
|
_fileID = 20;
|
|
command.SetParameter(0, _fileID);
|
|
_startByteCount = 0;
|
|
|
|
command.ShouldLog = false;
|
|
}
|
|
|
|
public Load_SliceProStackFirmwareImage(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
command.Parameter = new byte[PARAM_NUM];
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
_data = null;
|
|
|
|
_fileID = 20;
|
|
command.SetParameter(0, _fileID);
|
|
_startByteCount = 0;
|
|
|
|
command.ShouldLog = false;
|
|
}
|
|
#endregion
|
|
|
|
#region Log Functions
|
|
public override void CommandToString(ref List<List<string>> lines)
|
|
{
|
|
lines.Add(new List<string>() { $"Store ID: {_fileID}, Start Byte: {StartByteCount}, End Byte: {Size + StartByteCount}" });
|
|
}
|
|
|
|
public void LogResponse()
|
|
{
|
|
LogCommand(false);
|
|
}
|
|
#endregion
|
|
}
|
|
public class Start_SliceProStackFirmwareUpdate : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.Start_SliceProStackFirmwareUpdate;
|
|
|
|
public Start_SliceProStackFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
public Start_SliceProStackFirmwareUpdate(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public class Set_SliceProStackFirmwareUpdateMode : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.Set_SliceProStackFirmwareUpdateMode;
|
|
|
|
private int _sliceCount = 0;
|
|
private byte[] _sliceProUpdateMode;
|
|
|
|
public int SliceModuleCount
|
|
{
|
|
get => _sliceCount;
|
|
set
|
|
{
|
|
_sliceCount = value;
|
|
_sliceProUpdateMode = new byte[_sliceCount];
|
|
}
|
|
}
|
|
public byte[] SliceModuledateMode
|
|
{
|
|
get => _sliceProUpdateMode;
|
|
set
|
|
{
|
|
for (int i = 0; i < _sliceCount; i++)
|
|
{
|
|
_sliceProUpdateMode[i] = value[i];
|
|
}
|
|
command.Parameter = _sliceProUpdateMode;
|
|
}
|
|
}
|
|
|
|
public Set_SliceProStackFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
public Set_SliceProStackFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
}
|
|
|
|
public class Get_SliceProStackFirmwareUpdateMode : FirmwareUpdateCommands
|
|
{
|
|
protected override Commands _Command => Commands.Query_SliceProStackFirmwareUpdateMode;
|
|
|
|
public int SliceModuleCount { get; private set; } = 0;
|
|
public byte[] SliceModuledateMode { get; private set; }
|
|
|
|
public Get_SliceProStackFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock)
|
|
: base(sock)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
|
|
public Get_SliceProStackFirmwareUpdateMode(DTS.Common.Interface.DASFactory.ICommunication sock, int TimeoutMillisec)
|
|
: base(sock, TimeoutMillisec)
|
|
{
|
|
MinimumProtocolVersion = sock.GetMinProto(DFConstantsAndEnums.ProtocolLimitedCommands.StackFirmwareUpdate);
|
|
command.Type = CommandPacket.CommandType.FirmwareUpdate;
|
|
command.SetCommand((byte)_Command, _Command.ToString());
|
|
}
|
|
protected override CommandReceiveAction WholePackage()
|
|
{
|
|
if (response.Status == DFConstantsAndEnums.CommandStatus.StatusNoError)
|
|
{
|
|
SliceModuleCount = response.Parameter.Length;
|
|
SliceModuledateMode = new byte[SliceModuleCount];
|
|
|
|
for (int i = 0; i < SliceModuleCount; i++)
|
|
{
|
|
response.GetParameter(i, out SliceModuledateMode[i]);
|
|
}
|
|
}
|
|
return CommandReceiveAction.StopReceiving;
|
|
}
|
|
}
|
|
|
|
} |