/// <summary>
/// 上位机发送该命令将给定数据（4或8个字节）写入电子标签的指定数据块中。。
/// 上位机可指定的块的范围和每个块的大小会因电子标签的生产厂商的不同而有所差异。
/// 此命令为写类型命令，不同厂商的电子标签的响应机制会有所不同，它们可分为A类和B类两大类。
/// 该命令可以在address mode和select mode下运行。
/// </summary>
/// <param name="type">卡类型，A类或B类</param>
/// <param name="blockLen">卡的数据块所占空间的字节数，4或8</param>
/// <param name="blockNum">绝对块号</param>
/// <param name="data">写入的数据</param>
/// <returns></returns>
protected byte[] CreateWriteSingleBlockFrame(I15693CardType type, I15693BlockLen blockLen,
byte blockNum, byte[] data)
{
int len = (blockLen == I15693BlockLen.Four) ? 0x0A : 0x0E;
FrameBase frame = new FrameBase((byte)len, Com_adr);
byte[] db = frame.DataBlock;
db[2] = I15693Cmd.WriteSingleBlock;
//压入 State
if (blockLen == I15693BlockLen.Four) //块长度为 4 时
{
if (type == I15693CardType.TypeA) //为 A 类电子标签时
{
db[3] = (byte)0x01;
}
else //为 B 类电子标签时
{
db[3] = (byte)0x09;
}
}
else //块长度为 8 时
{
if (type == I15693CardType.TypeA) //为 A 类电子标签时
{
db[3] = (byte)0x05;
}
else //为 B 类电子标签时
{
db[3] = (byte)0x0D;
}
}
//压入 UID
db[4] = blockNum; //压入块号
data.CopyTo(db, 5); //压入要写入的数据
frame.PushCRC();
return(db);
}
/// <summary>
/// 上位机发送该命令读取电子标签中多个指定块的数据（每个块4或8个字节）和安全状态信息。
/// 当块的长度为4个字节时一次最多能读12个块，当块的长度为8个字节时一次最多能读6个块。
/// 上位机可指定的块的范围和每个块的大小因电子标签的生产厂商的不同而有所差异。
/// 该命令可以在address mode和select mode下运行。
/// </summary>
/// <param name="blockLen">卡的数据块所占空间的字节数，4或8</param>
/// <param name="uid">电子标签 UID，长度为 8 个字节</param>
/// <param name="start">读取的开始块号</param>
/// <param name="count">读取的块的个数</param>
/// <returns></returns>
protected byte[] CreateReadMultipleBlockFrame(I15693BlockLen blockLen,
byte[] uid, byte start, byte count)
{
FrameBase frame = new FrameBase(0x0F, Com_adr);
byte[] db = frame.DataBlock;
db[2] = I15693Cmd.ReadMultipleBlock;
//压入 State
if (blockLen == I15693BlockLen.Four) //块的字节数为4时的情况
{
db[3] = (byte)0x00;
}
else //为 B 类电子标签时
{
db[3] = (byte)0x04;
}
//压入 UID
uid.CopyTo(db, 4);
db[12] = start; //压入开始块号
db[13] = count; //压入读取长度
frame.PushCRC();
return(db);
}
protected byte[] CreateWriteCardFrame(byte WNum, byte ENum, byte[] EPC, MemoryArea Mem,
byte WordPtr, byte[] Wdt, byte[] Pwd, byte MaskAdr, byte MaskLen)
{
byte len = (byte)(14 + WNum * 2 + ENum * 2);
FrameBase frame = new FrameBase(len, Com_adr);
byte[] db = frame.DataBlock;
db[2] = I180006CCmd.WriteCard;
db[3] = WNum;
db[4] = ENum;
EPC.CopyTo(db, 5);
int index = 5 + ENum * 2;
db[index++] = (byte)Mem;
db[index++] = WordPtr;
Wdt.CopyTo(db, index);
index += Wdt.Length;
Pwd.CopyTo(db, index);
index += 4;
db[index++] = MaskAdr;
db[index] = MaskLen;
frame.PushCRC();
return(db);
}
/// <summary>
/// 原始数据解析
/// </summary>
/// <param name="OriginalBuffer"></param>
/// <returns></returns>
public override FrameBase ParsingReceivedData(byte[] OriginalBuffer)
{
Console.WriteLine("串口收到数据<<--" + this.Encoder.ByteEncode(OriginalBuffer));
FrameBase frame = new FrameBase(OriginalBuffer, null);
FrameBase.ResultOfParsingFrame result = frame.ParseToFrame(OriginalBuffer);
if (result.Equals(FrameBase.ResultOfParsingFrame.ReceivingCompleted))
{
int len = (int)OriginalBuffer[2];
if (OriginalBuffer.Length < len + 7)//数据接收不完整
{
Console.WriteLine("串口丢弃数据-->>" + this.Encoder.ByteEncode(OriginalBuffer));
return(null);
}
return(frame);
}
else
{
}
byte[] RawBuffer = null;
StringBuilder builder = new StringBuilder();
builder.Append(Encoding.ASCII.GetString(OriginalBuffer));
string receive_content = builder.ToString();
int CRLF_AT = -1;
CRLF_AT = receive_content.IndexOf("\r\n", 2);
if (CRLF_AT != -1)
{
string content = receive_content.Substring(0, CRLF_AT + 2);
RawBuffer = Encoding.ASCII.GetBytes(content);
return(new FrameBase(RawBuffer, new byte[] { }));
}
Console.WriteLine("串口丢弃数据-->>" + receive_content);
return(null);
}
protected virtual void notifyBase()
{
// 所有类都构造完成后通知FrameBase
FrameBase frameBase = new FrameBase();
frameBase.notifyConstructDone();
}
private void SerialPortManager_DataReceived(object sender, DataReceivedEventArgs e)
{
string packet = e.Data;
//Parse frame received
try
{
//PacketParser returns only AckOKFrame or AckOKFrame
FrameBase frame = PacketParser.Parse(packet);
//FrameId : 0 can be ACKKO Frame, for instance ACK_KO_BAD_FRAME_RECEIVED_FROM_SENDER (frame sent but not understood by receiver)
if (!_pendingLoRaFrames.TryRemove(frame.FrameId, out var tcs) && frame.FrameId != 0)
{
throw new InvalidPacketReceivedException("PendingLoRaFrames : Received frame with id : " + frame.FrameId + ", but frame has probably timed out !");
}
//FrameId : 0 can be ACKKO Frame, for instance ACK_KO_BAD_FRAME_RECEIVED_FROM_SENDER (frame sent but not understood by receiver)
if (!_sentLoRaFrames.TryRemove(frame.FrameId, out var sentFrame) && frame.FrameId != 0)
{
throw new InvalidPacketReceivedException("SentLoRaFrames : Received frame with id : " + frame.FrameId + ", but frame has probably timed out !");
}
//Sent arrived time when possible
//Careful sentFrame can be null here..when frameid = 0 for instance
if (sentFrame != null)
{
sentFrame.ArrivedTime = DateTime.Now.TimeOfDay.TotalMilliseconds;
}
//**********
//* ACK OK
//**********
if (frame is AckOKFrame frameOK)
{
frameOK.SentFrame = sentFrame;
OnFrameAckOkEvent(new FrameAckOKEventArgs(frameOK));
if (tcs != null) //Should not happen...
{
tcs.SetResult(frameOK);
}
}
//**********
//* ACK KO
//**********
if (frame is AckKOFrame frameKO)
{
frameKO.SentFrame = sentFrame;
OnFrameAckKoEvent(new FrameAckKOEventArgs(frameKO));
//tcs can be null if frameid = 0
if (tcs != null)
{
tcs.SetResult(frameKO);
}
}
}
catch (InvalidPacketReceivedException ipre)
{
_logger.Error(ipre.Message);
}
catch (Exception ex)
{
_logger.Error(ex, string.Format("Error occured while parsing a received packet : {0}", packet));
}
}
public LevelRecord(int number, uint recordSize, FrameBase parcelDataFrame) : base(parcelDataFrame)
{
Name = $"Level {number}";
_recordSize = recordSize;
}
public FrameBaseProxy(IFrame frame)
{
FrameBase = frame as FrameBase;
}
public BackgroundUnit(int number, FrameBase frame) : base(frame)
{
_number = number;
}
public void Initialisation()
{
FrameBase.Initialization();
scenarioName = featureName.CreateNode<Scenario>(_scenarioContext.ScenarioInfo.Title);
}
public string GetDataStr()
{
return(FrameBase.ByteSetToString(Data));
}
public BackgroundFrameRecord(FrameBase parentFrame)
{
_fileName = parentFrame.FileName;
}
public override async void Start(FrameBase frameBase)
{
var frame = frameBase as RequestFrame;
if (frame == null)
{
return;
}
Process process = new Process();
process.StartInfo.FileName = Common.Tools.Environment.ReplaceEnvironmentVars(frame.FileName);
process.StartInfo.Arguments = Common.Tools.Environment.ReplaceEnvironmentVars(frame.Arguments);
process.StartInfo.Verb = "runas";
if (frame.Hide)
{
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
}
if (frame.RedirectInput)
{
process.StartInfo.RedirectStandardInput = true;
}
if (frame.RedirectOutput)
{
process.StartInfo.RedirectStandardOutput = true;
}
if (frame.RedirectError)
{
process.StartInfo.RedirectStandardError = true;
}
if (frame.StartUtc.Ticks > 0)
{
TimeSpan startDelay = frame.StartUtc - DateTime.UtcNow;
if (startDelay.Ticks > 0)
{
await Task.Delay(startDelay).ConfigureAwait(false);
}
}
ProcessList.Add(frame.Guid, process);
try
{
process.Start();
if (frame.RedirectOutput)
{
ReadOutput(frame, process);
}
if (frame.RedirectError)
{
ReadError(frame, process);
}
if (frame.StopUtc.Ticks > 0)
{
KillTask(frame.StopUtc, process);
}
}
catch (Exception ex)
{
}
RemoveInstanceWhenExited(frame, process);
}
public ParcelInformationRecord(FrameBase frame) : base(frame)
{
}
public BlockSetRecord(int index, FrameBase parcelDataFrame) : base(parcelDataFrame)
{
Index = index;
}
/// <summary>
/// 服务端处理客户端信息循环。
/// </summary>
protected async void ClientLoop(TcpClient tc)
{
try
{
using (NetworkStream stream = tc.GetStream())
using (Timer timer = new Timer((object obj) => { stream.Close(); }, null, Timeout.Infinite, Timeout.Infinite))
{
await WriteFrame(stream, new Common.Frames.Information.RequestFrame()).ConfigureAwait(false);
timer.Change(Common.Configs.HelloTimeout, Timeout.Infinite);
var informationFrame = await ReadFrame(stream).ConfigureAwait(false) as Common.Frames.Information.AnswerFrame;
timer.Change(Timeout.Infinite, Timeout.Infinite);
if (informationFrame == null)
{
throw new Exception("Invalid Hello.");
}
ClientData client = new ClientData(this, tc, informationFrame);
try
{
OnConnect?.Invoke(client);
}
catch { }
try
{
Heartbeat(stream);
while (true)
{
timer.Change(Common.Configs.HeartbeatInterval * 3, Timeout.Infinite);
FrameBase frame = await ReadFrame(stream).ConfigureAwait(false);
timer.Change(Timeout.Infinite, Timeout.Infinite);
if (Common.Configs.Debug)
{
Console.WriteLine("R >" + frame.GetType().ToString());
}
OnFrame?.Invoke(client, frame);
}
}
catch { }
try
{
OnDisconnect?.Invoke(client);
}
catch { }
}
}
catch (Exception ex)
{
if (Common.Configs.Debug)
{
Console.WriteLine(ex.Message);
}
}
}
public RoadsFrameRecord(FrameBase parentFrame)
{
_fileName = parentFrame.FileName;
}
public FrameTimeOutEventArgs(FrameBase frameSent)
{
_frame = frameSent;
}
public string GetEPCStr()
{
return(FrameBase.UIDToString(EPC));
}
public static void Initialisation()
{
FrameBase.Initialization();
ScenarioContextStorage.createContext();
}
public void Start()
{
mGameScene = FrameBase.getCurScene();
}
public static void dropContextSTorage()
{
ScenarioContextStorage.resetContext();
FrameBase.TearDown();
}
public RouteGuidanceRecord(int index, int parcelType, FrameBase frame) : base(frame)
{
_index = index;
_parcelType = parcelType;
}
/// <summary> /// 启动并处理帧。 /// </summary> public abstract void Start(FrameBase frameBase);
public override async void Start(FrameBase frameBase)
{
var frame = frameBase as RequestFrame;
if (frame == null)
{
return;
}
try
{
byte[] buffer = new byte[4096];
frame.File = Common.Tools.Environment.ReplaceEnvironmentVars(frame.File);
using (HttpClient hc = new HttpClient())
{
using (Stream fileStream = new FileStream(frame.File, FileMode.OpenOrCreate, FileAccess.Write))
using (Stream netStream = await hc.GetStreamAsync(frame.Url).ConfigureAwait(false))
{
long len = -1, position = 0;
try
{
len = netStream.Length;
}
catch { }
using (Timer timerTimeout = new Timer((object obj) => { netStream.Close(); }, null, Timeout.Infinite, Timeout.Infinite))
using (Timer timerAnswer = new Timer((object obj) => { SendStatus(frame, len, position); }, null, frame.AnswerInterval, frame.AnswerInterval))
{
while (position != len)
{
timerTimeout.Change(5000, Timeout.Infinite);
int count = await netStream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
timerTimeout.Change(Timeout.Infinite, Timeout.Infinite);
if (count == 0)
{
if (len == -1)
{
break;
}
else
{
throw new IOException("下载意外终止。");
}
}
await fileStream.WriteAsync(buffer, 0, count).ConfigureAwait(false);
position += count;
}
}
SendStatus(frame, position, position);
}
}
}
catch (Exception ex)
{
await SendError(frame, ex.Message).ConfigureAwait(false);
}
}
public void Transmit(FrameBase frame)
{
Console.WriteLine(frame.GetType().Name);
}
public BlockRecord(int number, FrameBase frame) : base(frame)
{
Index = number;
}
/// <summary>
/// 分配链接
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public override IConnection GetConnection(FrameBase frame)
{
return(base.GetConnection(frame));
}
public virtual void CopyFrom(FrameBase sourceFrame)
{
content = sourceFrame.content;
}
public Boolean Filter(FrameBase frame, DynamicScene.Manifold manifold)
{
return(true);
}
