private int SetParameters(PktType type, string cmd, string parameters)
{
int ret = WritePacket(true, type, Encoding.ASCII.GetBytes(cmd), Encoding.ASCII.GetBytes(parameters));
if (ret != 0)
{
return(ret);
}
ret = ReadByte();
if (ret == EOT)
{
return(PacketNotAccepted); //Packet was not accepted by device
}
byte[] Recv = null;
ret = ReadPacket(out Recv, type);
if (ret < 0)
{
return(ret);
}
if (type == PktType.SI && !CheckEOT(2000))
{
return(ReadEOTTimeOut);
}
return(Recv[2]);
//if (Recv[3] == 0x30) return Recv[3];// == '0'
//else return ExecFail;
}
void client_DataReceived(Client sender, ReceiveBuffer e)
{
try
{
DataPacket.Packet pkt = DataPacket.DataParser(e.BufStream, e.pkt);
PktType header = pkt.type;
UpdateCompLogMsg(sender.name + " - Received data: " + pkt.ToString());
switch (header)
{
case PktType.AUTH:
UpdateReceivedImage(pkt.fingerPrint);
UpdateCompMatchedUser(sender.RunAuth(pkt));
//sender.RunAuth(pkt);
break;
case PktType.PASSENGER:
sender.RunPassenger(pkt);
break;
case PktType.ORDER:
sender.RunOrder(pkt);
break;
case PktType.ONCE:
UpdateReceivedImage(pkt.fingerPrint);
UpdateCompMatchedUser(sender.RunAtOnce(pkt));
break;
}
}
catch (Exception ee)
{
UpdateCompLogMsg(ee.Message);
}
}
public static MemoryStream NewPkt(PktType p)
{
var ms = new MemoryStream();
ms.WriteShort(_Header);
ms.WriteShort((int)p);
ms.WriteInt((int)ms.Length - HeadLength);
return ms;
}
private int WritePacket(bool IsSync, PktType type, byte[] MsgId, byte[] data)
{
if (_CommMode != UsbMode.ACM && _IsOpen == true)
{
return(InstanceofHID.WritePacket(IsSync, type, MsgId, data));
}
if (_CommMode == UsbMode.ACM && _IsOpen == true)
{
return(InstanceofVC.WritePacket(IsSync, type, MsgId, data));
}
else
{
return(-1);
}
}
public int WritePacket(bool IsSync, PktType type, byte[] DataIn)
{
if (_CommMode != UsbMode.ACM && _IsOpen == true)
{
return(InstanceofHID.WritePacket(IsSync, type, DataIn));
}
if (_CommMode == UsbMode.ACM && _IsOpen == true)
{
return(InstanceofVC.WritePacket(IsSync, type, DataIn));
}
else
{
return(-1);
}
}
private int ReadPacket(out byte[] data, PktType Type)
{
data = null;
if (_CommMode != UsbMode.ACM && _IsOpen == true)
{
return(InstanceofHID.ReadPacket(out data, Type));
}
if (_CommMode == UsbMode.ACM && _IsOpen == true)
{
return(InstanceofVC.ReadPacket(out data, Type));
}
else
{
return(-1);
}
}
static bool ParseHeader(byte[] buf, int offset, int buflen, out int len, out PktType pt)
{
len = 0;
pt = PktType.ErrClose;
if (buflen - offset < HeadLength) {
return false;
}
var h = buf.GetShort(ref offset);
pt = (PktType)buf.GetShort(ref offset);
len = buf.GetInt(ref offset);
if (h != _Header) {
pt = PktType.ErrClose;
return true;
}
offset += len;
if (offset > buflen) {
return false;
}
return true;
}
public int Getter(PktType type, string cmd, string parameters, out byte[] dataout)
{
dataout = null;
int ret = WritePacket(true, type, Encoding.ASCII.GetBytes(cmd), Encoding.ASCII.GetBytes(parameters));
if (ret != 0)
{
return(ret);
}
ret = ReadByte();
if (ret == EOT)
{
return(PacketNotAccepted); //Packet was accepted by device, go on
}
byte[] Recv = null;
ret = ReadPacket(out Recv, type);
if (type == PktType.SI && !CheckEOT(2000))
{
return(ReadEOTTimeOut);
}
dataout = Recv;
//new List<byte>(time).GetRange(3, time.Length).ToArray();
return(ret > 0 ? 0 : ret);
}
public void WriteAndReadMessage(PktType type, string head, string body, out string responseOut, bool keepWaitting = true, int readTimeOut = 0)
{
string prefix = String.Empty;
string suffix = String.Empty;
responseOut = String.Empty;
if (type == PktType.SI)
{
prefix = Convert.ToChar(0x0F).ToString();
suffix = Convert.ToChar(0x0E).ToString();
}
else if (type == PktType.STX)
{
prefix = Convert.ToChar(0x02).ToString();
suffix = Convert.ToChar(0x03).ToString();
}
string packed_meaasge = prefix + head + body + suffix;
byte lrc = DataManager.LRCCalculator(Encoding.ASCII.GetBytes(packed_meaasge), packed_meaasge.Length);
if (_serialPort.BytesToRead > 0)
{
_serialPort.DiscardInBuffer();
}
if (_serialPort.BytesToWrite > 0)
{
_serialPort.DiscardOutBuffer();
}
// Sending message
try
{
_serialPort.Write(packed_meaasge + Convert.ToChar(lrc).ToString());
/*
* if (OnDataSent != null)
* {
* byte[] data_sent = Encoding.ASCII.GetBytes(packed_meaasge + Convert.ToChar(lrc).ToString());
* OnDataSent(this, data_sent);
* }
*/
}
catch (Exception ex)
{
throw new System.Exception(string.Format("Sending message failed: {0}", ex.Message));
}
// Check if ACK is received
try
{
byte[] controlCode = new byte[1];
_serialPort.Read(controlCode, 0, 1);
if (OnDataReceived != null)
{
OnDataReceived(this, controlCode);
}
switch (controlCode[0])
{
case 0x06:
case 0x04:
break;
case 0x15:
// NAK
throw new System.Exception("Received NAK from reader: Incorrect LRC.");
default:
// Unknown
throw new System.Exception("Unknown response: 0x" + controlCode[0].ToString("X2"));
}
}
catch (TimeoutException)
{
// Reader no response;
throw new System.TimeoutException("Timeout: No ACK");
}
catch (Exception ex)
{
throw new System.Exception(string.Format("Waitting ACK failed: {0}", ex.Message));
}
if (!keepWaitting)
{
return;
}
int response_length = 0;
byte[] readBuffer = new byte[_serialPort.ReadBufferSize];
byte bPrefix, bSuffix;
if (type == PktType.SI)
{
bPrefix = 0x0F;
bSuffix = 0x0E;
}
else
{
bPrefix = 0x02;
bSuffix = 0x03;
}
try
{
// Waitting for reply from reader
Stopwatch s = new Stopwatch();
if (readTimeOut > 0)
{
s.Start();
}
while (s.Elapsed <= TimeSpan.FromMilliseconds(readTimeOut))
{
if (_serialPort.BytesToRead == 0)
{
continue;
}
int bytes = _serialPort.BytesToRead;
_serialPort.Read(readBuffer, response_length, bytes);
response_length += bytes;
if (response_length > 2 && readBuffer[0] == bPrefix && readBuffer[response_length - 2] == bSuffix)
{
if (OnDataReceived != null)
{
byte[] localBuffer = new byte[response_length];
Array.Copy(readBuffer, localBuffer, response_length);
OnDataReceived(this, localBuffer);
}
// LRC check
if (readBuffer[response_length - 1] == DataManager.LRCCalculator(readBuffer, response_length - 1))
{
// Send ACK
_serialPort.Write(Convert.ToChar(0x06).ToString());
if (OnDataSent != null)
{
byte[] ack = Encoding.ASCII.GetBytes(Convert.ToChar(0x06).ToString());
OnDataSent(this, ack);
}
responseOut = Encoding.ASCII.GetString(readBuffer, 1, response_length - 3);
}
else
{
// Send NAK
_serialPort.Write(Convert.ToChar(0x15).ToString());
if (OnDataSent != null)
{
byte[] nak = Encoding.ASCII.GetBytes(Convert.ToChar(0x15).ToString());
OnDataSent(this, nak);
}
}
return;
}
}
s.Reset();
// Timeout
throw new System.TimeoutException("Timeout: No response");
}
catch (Exception ex)
{
throw new System.Exception(string.Format("Waitting response failed: {0}", ex.Message));
}
}
internal void OnPkt(EasyAdapter adapter, PktType tp, byte[] buf, int offset, int length)
{
_bufhelper.Init(buf, offset, length);
int ii = (int)tp;
if ((ii >= 0) && (ii < _calls.Length)) {
var f = _calls[ii];
if (f != null) {
f(adapter, buf, offset, length);
}
}
}
void OnRpcAck(PktType t, EasyAdapter adapter, byte[] buf, int offset, int length)
{
int msgid = _bufhelper.ReadInt();
int source = _bufhelper.ReadInt();
int destination = _bufhelper.ReadInt();
EasyAdapter dest = null;
_AllAdapters.TryGetValue(destination, out dest);
if (adapter != null) {
var ms = PktHelper.NewPkt(t);
ms.Write(buf, offset, length);
PktHelper.ClosePkt(ms);
dest.WriteStream(ms);
}
}
void OnPkt(PktType pt, byte[] buf, int offset, int length)
{
_bufhelper.Init(buf, offset, length);
int ii = (int)pt;
if ((ii >= 0) && (ii < _calls.Length)) {
var f = _calls[ii];
if (f != null) {
f(buf, offset, length);
}
}
}
void OnPkt(PktType pt, byte[] buf, int offset, int length)
{
broker.OnPkt(this, pt, buf, offset, length);
}
