/// <summary>
/// 初始化协议驱动
/// </summary>
/// <param name="cmdAsmType">带命令驱动的程序集类型</param>
/// <param name="receiveFilter"></param>
public virtual void InitDriver(Type cmdAsmType, IReceiveFilter receiveFilter)
{
ReceiveFilter = receiveFilter;
this._Commands.Clear();
System.Reflection.Assembly asm = cmdAsmType.Assembly;
Type[] types = asm.GetTypes();
foreach (Type t in types)
{
if (typeof(IProtocolCommand).IsAssignableFrom(t))
{
if (t.Name != "IProtocolCommand" &&
t.Name != "ProtocolCommand" &&
!t.IsAbstract)
{
IProtocolCommand cmd = (IProtocolCommand)t.Assembly.CreateInstance(t.FullName);
if (cmd != null)
{
cmd.Setup(this);
_Commands.TryAdd(cmd.Name, cmd);
}
}
}
}
}
public IProtocolPackage EncodeCommand(IProtocolCommand command, Dictionary <string, byte[]> paramBytes = null)
{
var package = new BytesProtocolPackage(command)
{
[StructureNames.CmdType] = { ComponentContent = command.CommandTypeCode },
[StructureNames.CmdByte] = { ComponentContent = command.CommandCode }
};
foreach (var definition in command.CommandDefinitions)
{
package[definition.StructureName].ComponentContent = definition.ContentBytes;
}
if (paramBytes != null)
{
foreach (var paramByte in paramBytes)
{
package[paramByte.Key].ComponentContent = paramByte.Value;
}
}
var crcValue = Globals.GetUsmbcrc16(package.GetBytes(), (ushort)(package.PackageLenth - 3));
package[StructureNames.CRCValue].ComponentContent = Globals.Uint16ToBytes(crcValue, false);
package.Finalization();
return(package);
}
public ChannelProtocol(IProtocolCommand parent, int channelNumber) : base(parent)
{
ChannelNumber = channelNumber;
PathParameter = channelNumber;
BWLimit = new ProtocolCommand(this, "Bandwidth Limit", "BWL")
{
Options = StringOptions.BWLimit,
};
Coupling = new ProtocolCommand(this, "Coupling", "COUP")
{
Options = StringOptions.Coupling,
};
Display = new ProtocolCommand(this, "Display", "DISP")
{
Options = BooleanOptions.Boolean,
};
Invert = new ProtocolCommand(this, "Invert", "INV")
{
Options = BooleanOptions.Boolean,
};
Offset = new ProtocolCommand(this, "Offset", "OFFS")
{
Options = RealOptions.ChannelOffset_ScaleGreaterThan500m,
};
Range = new ProtocolCommand(this, "Range", "RANG")
{
Options = RealOptions.ChannelRange,
};
TCal = new ProtocolCommand(this, "TCal", "TCAL")
{
Options = RealOptions.ChannelTCal,
};
Scale = new ProtocolCommand(this, "Scale", "SCAL")
{
Options = RealOptions.ChannelScale,
};
Probe = new ProtocolCommand(this, "Probe", "PROB")
{
Options = StringOptions.ProbeRatio,
};
Units = new ProtocolCommand(this, "Units", "UNIT")
{
Options = StringOptions.Units,
};
Vernier = new ProtocolCommand(this, "Vernier", "VERN")
{
Options = BooleanOptions.Boolean,
};
}
public TimebaseProtocol(IProtocolCommand parent) : base(parent)
{
Delay = new TimebaseDelayCommands(this);
Offset = new ProtocolCommand(this, "Offset", "OFFS")
{
Path = ":MAIN:OFFS",
// depends on whether scope is in slow sweep mode
// Normal : (-0.5 x MemDepth / SampleRate) to 1s
// Slow sweep: (-MemDepth/SampleRate) to (1s + 0.5 x MemDepth/SampleRate)
// Highest memdepth is 24000000
// MemDepth = SampleRate x WaveformLength
// WaveformLength = Scale x number of scales
// number of scales for DS1000Z is 12
Options = new RealOptions(-12, 12)
};
Scale = new ProtocolCommand(this, "Scale", "SCAL")
{
Path = ":MAIN:SCAL",
// YT mode : 5ns/div to 50s/div in 1,2,5 steps
// Roll mode: 200ms/div to 50s/div in 1,2,5 steps
Options = TimebaseScaleOptions.YT,
};
Mode = new ProtocolCommand(this, "Mode", "MODE")
{
Options = new StringOptions
{
new StringOption("Main", "MAIN"),
new StringOption("XY", "XY"),
new StringOption("Roll", "ROLL"),
}
};
}
public StringProtocolPackage(IProtocolCommand command)
{
Protocol = command.Protocol;
Command = command;
foreach (var structure in Protocol.ProtocolStructures)
{
var component = new PackageComponent <string>()
{
ComponentName = structure.StructureName,
DataType = structure.DataType,
ComponentIndex = structure.StructureIndex,
ComponentContent = Encoding.ASCII.GetString(structure.DefaultBytes)
};
this[structure.StructureName] = component;
}
foreach (var commandData in command.CommandDatas)
{
var component = new PackageComponent <string>()
{
ComponentName = commandData.DataName,
DataType = commandData.DataConvertType,
ComponentIndex = commandData.DataIndex
};
AppendData(component);
}
}
public TriggerWindowsCommands(IProtocolCommand parent) : base(parent)
{
Source = new TriggerSourceChannelCommand(this);
Slope = new TriggerSlopeCommand(this);
Time = new TriggerTimeCommand(this)
{
Options = new RealOptions(8 * SI.n, 10)
};
Position = new ProtocolCommand(this)
{
Name = "POSition",
Term = "POS",
Options = new StringOptions()
{
new StringOption("EXIT", "EXIT"),
new StringOption("ENTER", "ENTER"),
new StringOption("TIMe", "TIM"),
}
};
ALevel = new TriggerLevelCommand(this);
BLevel = new TriggerLevelCommand(this);
}
public TriggerNEdgeCommands(IProtocolCommand parent) : base(parent)
{
Source = new TriggerSourceCommand(this);
Slope = new TriggerSlopeCommand(this)
{
Options = new StringOptions {
new StringOption("POSitive", "POS"),
new StringOption("NEGative", "NEG"),
}
};
Idle = new TriggerTimeCommand(this)
{
Name = "IDLE",
Term = "IDLE",
Options = new RealOptions
{
new RealOption(16 * SI.n, 10)
}
};
Edge = new ProtocolCommand(this)
{
Name = "EDGE",
Term = "EDGE",
Options = new IntegerOptions {
new IntegerOption(1, 65535)
}
};
Level = new TriggerLevelCommand(this);
}
public void DriverCommand <T1, T2>(string cmdName, T1 t1, T2 t2)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
cmd.ExcuteCommand <T1, T2>(t1, t2);
}
}
public TriggerEdgeCommands(IProtocolCommand parent) : base(parent)
{
Source = new TriggerSourceCommand(this)
{
Description = "The trigger source in edge trigger",
};
Slope = new TriggerSlopeCommand(this);
Level = new TriggerLevelCommand(this);
}
/// <summary>
/// 驱动命令
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cmdName"></param>
/// <param name="t"></param>
public void DriverCommand <T>(string cmdName, T t)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
cmd.ExcuteCommand <T>(t);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="code"></param>
/// <param name="cmdName"></param>
/// <param name="t1"></param>
/// <param name="t2"></param>
/// <returns></returns>
public byte[] DriverPackage <T1, T2>(string code, string cmdName, T1 t1, T2 t2)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
return(cmd.Package <T1, T2>(code, t1, t2));
}
else
{
return(null);
}
}
public TriggerTimeoutCommands(IProtocolCommand parent) : base(parent)
{
Source = new TriggerSourceCommand(this);
Slope = new TriggerSlopeCommand(this);
Time = new ProtocolCommand(this)
{
Name = "TIMe",
Term = "TIM",
Options = new RealOptions(16 * SI.n, 10),
};
}
/// <summary>
/// 打包数据
/// </summary>
/// <param name="addr"></param>
/// <param name="cmdName"></param>
/// <param name="obj"></param>
/// <returns></returns>
public byte[] DriverPackage(int addr, string cmdName, object obj)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
return(cmd.Package(addr, obj));
}
else
{
return(null);
}
}
/// <summary>
/// 解析数据
/// </summary>
/// <param name="cmdName"></param>
/// <param name="data"></param>
/// <param name="obj"></param>
/// <returns></returns>
public object DriverAnalysis(string cmdName, byte[] data, object obj)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
return(cmd.Analysis(data, obj));
}
else
{
return(null);
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="cmdName"></param>
/// <param name="data"></param>
/// <param name="t1"></param>
/// <param name="t2"></param>
/// <returns></returns>
public dynamic DriverAnalysis <T1, T2>(string cmdName, byte[] data, T1 t1, T2 t2)
{
IProtocolCommand cmd = GetProcotolCommand(cmdName);
if (cmd != null)
{
return(cmd.Analysis <T1, T2>(data, t1, t2));
}
else
{
return(null);
}
}
public TriggerSHoldCommands(IProtocolCommand parent) : base(parent)
{
DataSource = new TriggerSourceChannelCommand(this);
ClockSource = new TriggerSourceChannelCommand(this);
Slope = new TriggerSlopeCommand(this)
{
Options = new StringOptions
{
new StringOption("POSitive", "POS"),
new StringOption("NEGative", "NEG"),
}
};
Pattern = new TriggerPatternCommands(this)
{
Options = new StringOptions()
{
new StringOption("H", "H"),
new StringOption("L", "L"),
}
};
Type = new ProtocolCommand(this)
{
Name = "TYP",
Term = "TYP",
Options = new StringOptions
{
new StringOption("SETup", "SET"),
new StringOption("HOLd", "HOL"),
new StringOption("SETHOLd", "SETHOL"),
}
};
SetupTime = new TriggerTimeCommand(this)
{
Name = "SHOLd",
Term = "SHOL",
Options = new RealOptions(8 * SI.n, 1),
};
HoldTime = new TriggerTimeCommand(this)
{
Name = "HTIMe",
Term = "HTIM",
Options = new RealOptions(8 * SI.n, 1),
};
}
public TriggerSlopeCommands(IProtocolCommand parent) : base(parent)
{
Source = new ProtocolCommand(this)
{
Name = "SOURce",
Term = "SOUR",
Options = new StringOptions
{
new StringOption("CH1", "CHAN1"),
new StringOption("CH2", "CHAN2"),
new StringOption("CH3", "CHAN3"),
new StringOption("CH4", "CHAN4"),
}
};
}
public TriggerDelayCommands(IProtocolCommand parent) : base(parent)
{
SourceA = new TriggerSourceChannelCommand(this)
{
Name = "SourceA",
Term = "SA",
};
SlopeA = new TriggerSlopeCommand(this)
{
Name = "SLOPeA",
Term = "SLOPA",
};
SourceB = new TriggerSourceChannelCommand(this)
{
Name = "SourceB",
Term = "SB",
};
SlopeB = new TriggerSlopeCommand(this)
{
Name = "SLOPeB",
Term = "SLOPB",
};
Type = new TriggerTypeCommand(this);
TUpper = new TriggerTimeCommand(this)
{
Name = "TUPPer",
Term = "TUPP",
Options = new RealOptions()
{
new RealOption(16 * SI.n, 10)
}
};
TLower = new TriggerTimeCommand(this)
{
Name = "TLOWer",
Term = "TLOW",
Options = new RealOptions()
{
new RealOption(8 * SI.n, 10)
}
};
}
public TriggerPatternCommands(IProtocolCommand parent) : base(parent)
{
Pattern = new ProtocolCommand(this)
{
Name = "PATTern",
Term = "PATT",
Options = new StringOptions
{
new StringOption("H", "H"),
new StringOption("L", "L"),
new StringOption("X", "X"),
new StringOption("R", "R"),
new StringOption("F", "F"),
}
};
Level = new TriggerLevelCommand(this);
}
public ScopeCommand(IProtocolVM viewModel, IProtocolCommand protocolCommand, string defaultResponse)
{
//ViewModel = viewModel;
ProtocolCommand = protocolCommand;
if (protocolCommand.IsSettable)
{
var canSet = this.WhenValueChanged(x => x.IsEnabled)
.Where(x => x == true);
SetCommand = ReactiveCommand.CreateFromTask(SendCommandAsync, canSet);
SetCommand.ThrownExceptions.SubscribeOnUI().Subscribe(async ex => await DisplayException(ex, "Couldn't set"));
Increment = ReactiveCommand.Create(IncrementValue);
Increment.ThrownExceptions.SubscribeOnUI().Subscribe(async ex => await DisplayException(ex, "Couldn't increment"));
Decrement = ReactiveCommand.Create(DecrementValue);
Decrement.ThrownExceptions.SubscribeOnUI().Subscribe(async ex => await DisplayException(ex, "Couldn't decrement"));
}
else
{
// set command is used to send the command without a value or response
SetCommand = ReactiveCommand.CreateFromTask(SendCommandAsync);
}
if (protocolCommand.IsQueryable)
{
if (App.Mock)
{
DefaultResponse = defaultResponse;
}
GetCommand = ReactiveCommand.CreateFromTask(SendQueryAsync);
GetCommand.ThrownExceptions.SubscribeOnUI().Subscribe(async ex => await DisplayException(ex, "Couldn't query"));
}
else
{
if (App.Mock)
{
DefaultResponse = null;
}
IsEnabled = true;
}
}
/// <summary>
/// 初始化驱动
/// </summary>
public virtual void InitDriver(IRunDevice runDevice)
{
this._Commands.Clear();
Assembly asm = runDevice.GetType().Assembly;
Type[] types = asm.GetTypes();
foreach (Type t in types)
{
if (typeof(IProtocolCommand).IsAssignableFrom(t))
{
if (t.Name != "IProtocolCommand" && t.Name != "ProtocolCommand")
{
IProtocolCommand cmd = (IProtocolCommand)t.Assembly.CreateInstance(t.FullName);
if (cmd != null)
{
cmd.Setup(this);
_Commands.TryAdd(cmd.Name, cmd);
}
}
}
}
}
public TimebaseDelayCommands(IProtocolCommand parent) : base(parent)
{
Enable = new TimebaseEnableCommand(this);
Offset = new ProtocolCommand(this, "Offset", "OFFS")
{
// LeftTime = 6x MainScale - MainOffset
// RightTime = 6x MainScale - MainOffset
// DelayRange = 12x DelayScale
Options = new RealOptions(-12, 12)
};
Scale = new ProtocolCommand(this, "Scale", "SCAL")
{
// max scale: MainScale
// min scale: 50 / (SampleRate x AmplificationFactor)
// Amplification factor is (10 x the sum of):
// Number of enabled analog channels
// Number of analog channels set as trigger sources
// Number of enabled digital channel groups (D0 to D7 is one, D8 to D15 is the other)
// TODO: This needs more work, I'm just guessing here
Options = new RealOptions(10 * SI.n, 50)
};
}
public IProtocolPackage EncodeCommand(IProtocolCommand command, Dictionary <string, byte[]> paramBytes = null)
{
throw new NotImplementedException();
}
public ProtocolSimpleCommand(IProtocolCommand parent, string name, string term)
: base(parent, name, term)
{
}
public ProtocolCommand(IProtocolCommand parent, object pathParameter)
{
Parent = parent;
PathParameter = pathParameter;
}
public ProtocolCommand(IProtocolCommand parent, string name, string term)
{
Parent = parent;
Name = name;
Term = term;
}
public ProtocolCommand(IProtocolCommand parent)
{
Parent = parent;
}
public static byte[] Serialize(IProtocolCommand command)
{
StringBuilder Sb = new StringBuilder();
Sb.Append(command.Command + "`" + command.From + "`" + command.To + "`" + command.Id.ToString() + "`");
foreach (object o in command.Parameters)
{
Sb.Append(o.ToString() + "`");
}
string commandStr = Sb.ToString(0, Sb.Length - 1);
System.Text.ASCIIEncoding encoding = new ASCIIEncoding();
return encoding.GetBytes(commandStr);
}
public TriggerWhenCommand(IProtocolCommand parent) : base(parent)
{
}
public TriggerRuntCommands(IProtocolCommand parent) : base(parent)
{
Source = new TriggerSourceCommand(this);
}
private void Send(IProtocolCommand cmd, ConnectionState state)
{
Logger.WriteLine("Sending Command from: " + state.RemoteEndPoint.ToString() + " - " + cmd.Command, Logger.Severity.Debug, state.LOGNAME);
byte[] dataToSend = ProtocolCommand.Serialize(cmd);
bool status = state.Write(dataToSend, 0, dataToSend.Length);
if (!status)
{
state.EndConnection();
}
}
public override IProtocolCommand Send(IProtocolCommand cmd)
{
IProtocolCommand receiveCmd = _client.Send(ProtocolCommand.Serialize(cmd));
return receiveCmd;
}
/// <summary> /// 协议编码 /// </summary> /// <param name="command">指定的指令</param> /// <param name="paramBytes"></param> /// <returns>协议字节流</returns> public static byte[] EncodeProtocol(IProtocolCommand command, Dictionary <string, byte[]> paramBytes = null) => UnityFactory.Resolve <ICommandCoder>(command.Protocol.ProtocolModule).EncodeCommand(command, paramBytes).GetBytes();
