public void Start()
{
TransactionUser.NuevaSolicitud(pdu, this, Transport);
if (pdu.RequiresAnswer)
{
rta = TransactionUser.RequieroRespuesta(pdu, this, Transport);
rta.DeviceId = pdu.DeviceId;
rta.Destination = pdu.Destination;
rta.Seq = pdu.Seq;
}
else
{
rta = new PDU
{
DeviceId = pdu.DeviceId,
Seq = pdu.Seq,
Options = pdu.Options,
Destination = pdu.Destination,
CH = ((byte)Decoder.ComandoH.OKACK),
CL = ResponseCL
};
}
Transport.Send(rta);
SetupDisposeTimer();
if (pdu.RequiresACK)
{
State = States.RESPONDIENDO;
SetupRetryTimer();
}
else
{
State = States.CONFIRMANDO;
}
}
public override bool send(PDU<object> pdu)
{
var pduOut = this.composePdu(pdu);
var data = pduOut.data as byte[];
return _client.Write(data);
}
public override void SolicitudEntregada(PDU rta, PDU source, Transaction tr, AbstractTransport t)
{
if (rta.CH == (byte)Decoder.ComandoH.LoginAcepted && LoginSuccess != null)
{
var la = rta as LoginAcepted;
if (la == null)
{
throw new Exception("SA: fallo la especializacion del PDU");
}
LoginSuccess(this, la.IdAsignado);
}
else if (rta.CH == (byte)Decoder.ComandoH.LoginReject && LoginFail != null)
{
var lr = rta as LoginReject;
if (lr == null)
{
throw new Exception("SA: fallo la especializacion del PDU");
}
LoginFail(this, lr.CL);
}
else if (rta.CH == (byte)Decoder.ComandoH.OKACK)
{
if (source.CH == (byte)Decoder.ComandoH.MsgPosicion && AutoReportSuccess != null)
{
var pos = source as Posicion;
if (pos == null)
{
throw new Exception("SA: fallo la especializacion del PDU");
}
AutoReportSuccess(this, pos.IdQueue);
}
}
}
private void TraceReceived(PDU pdu)
{
if (TraceWriter != null)
{
NetUtils.TraceOutput(TraceWriter, "Received ", pdu);
}
}
public override ModbusTCPMessage Process(IMemoryModel memory)
{
int address = Int16Extensions.FromBytes(PDU.Data.First(), PDU.Data.Skip(1).First());
int length = Int16Extensions.FromBytes(PDU.Data.Skip(2).First(), PDU.Data.Skip(3).First());
try
{
var values = memory.Read4x(address, length);
ProtocolDataUnit pdu = PDU.ValidResponse(
new byte[]
{ (byte)(values.Count() * 2) }
.Concat(values.SelectMany(v => v.GetBytes())));
ModbusTCPMessage reply = Create(
MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
pdu);
return(reply);
}
catch
{
ProtocolDataUnit pdu = PDU.ErrorResponse(new byte[] { 0x01 });
ModbusTCPMessage reply = Create(
MBAP.Create((byte)(pdu.GetBytes().Count() + 1), ApplicationHeader.UnitID),
pdu);
return(reply);
}
}
protected override void RunNow()
{
while (CanContinue())
{
try
{
PDU pdu = WaitPDU();
if (pdu is RequestPDU)
{
#if NET40
vProcessorCallback.BeginInvoke((RequestPDU)pdu, AsyncCallBackProcessPduRequest, null); //old
#else
System.Threading.Tasks.Task.Run(() => vProcessorCallback.Invoke((RequestPDU)pdu)); //new
#endif
}
else if (pdu is ResponsePDU)
{
vResponseHandler.Handle(pdu as ResponsePDU);
}
}
catch (PDUException) { /*Silent catch*/ }
catch (TcpIpException) { /*Silent catch*/ }
catch (Exception ex)
{
_Log.ErrorFormat("200015:Unanticipated stream parser exception: {0}", ex, ex.Message);
if (vTraceSwitch.TraceError)
{
Trace.WriteLine(string.Format(
"200015:Unanticipated stream parser exception:{0};", ex));
}
throw;
}
}
}
public override PDU<object> receive()
{
var pduReceived = new PDU<object>();
if (this.serialPort.BytesToRead > 0)
{
char[] frameHeader = new char[8];
this.serialPort.Read(frameHeader, 0, 8);
var pduInput = new string(frameHeader);
var keyLength = int.Parse(pduInput.Substring(2, 3));
var dataLength = int.Parse(pduInput.Substring(5, 3));
char[] frameBuffer = new char[120];
this.serialPort.Read(frameBuffer, 0, keyLength + dataLength);
char[] frame = new char[128];
for (int i = 0; i < 8; i++)
{
frame[i] = frameHeader[i];
}
for (int i = 0; i < (keyLength + dataLength); i++)
{
frame[i + 8] = frameBuffer[i];
}
pduReceived.data = frame;
}
return pduReceived;
}
public override void RecibePDU(PDU received_pdu)
{
STrace.Debug(GetType().FullName, String.Format("MRS: ReceivePDU: Estado={0} ReceivedPDU.CH={1} PDU.CH={2}", Estado, received_pdu.CH, pdu.CH));
switch (Estado)
{
case Estados.CONFIRMANDO:
if (received_pdu.CH == pdu.CH)
{
if (pdu.CH == 0x10 && Transporte.UseSeqCache && Transporte.SeqCache != pdu.Seq)
{
break;
}
Transporte.Send(rta);
}
break;
case Estados.RESPONDIENDO:
if (received_pdu.CH != pdu.CH)
{
Estado = Estados.TERMINADO;
TransactionUser.RespuestaEntregada(received_pdu, this, Transporte);
Transporte.TransaccionCompleta(this, pdu);
}
break;
default:
STrace.Debug(GetType().FullName, String.Format("MRS: Error en recibo PDU, el estado es inconsistente state={0}", Estado));
Estado = Estados.TERMINADO;
Transporte.TransaccionCompleta(this, pdu);
break;
}
}
public MRS(PDU _pdu, Transporte t, TransactionUser ut)
: base(t, ut)
{
pdu = _pdu;
Seq = pdu.Seq;
IdDispositivo = pdu.IdDispositivo;
}
private void TraceSending(PDU pdu)
{
if (TraceWriter != null)
{
NetUtils.TraceOutput(TraceWriter, "Sending ", pdu);
}
}
protected override void RunNow()
{
while (CanContinue())
{
try
{
PDU pdu = WaitPDU();
if (pdu is RequestPDU)
{
vProcessorCallback.BeginInvoke(
(RequestPDU)pdu, AsyncCallBackProcessPduRequest, null);
}
else if (pdu is ResponsePDU)
{
vResponseHandler.Handle(pdu as ResponsePDU);
}
}
catch (PDUException) { /*Silent catch*/ }
catch (TcpIpException) { /*Silent catch*/ }
catch (Exception ex)
{
if (vTraceSwitch.TraceError)
{
Trace.WriteLine(string.Format(
"200015:Unanticipated stream parser exception:{0};", ex));
}
throw;
}
}
}
/// <summary>
/// Compose PDU from given input
/// </summary>
/// <param name="pduInput"></param>
/// <returns></returns>
protected override PDU<object> composePdu(PDU<object> pduInput)
{
PDU<object> pduCommand = null;
var dataTuple = pduInput.data as Tuple<string, string>;
if (dataTuple != null)
{
var version = string.Format("{0:D2}", ProtocolVersion);
var dataLength = string.Format("{0:D3}", dataTuple.Item2.Length);
var keyLength = string.Format("{0:D3}", dataTuple.Item1.Length);
var composedData = new StringBuilder();
composedData.Append(version)
.Append(keyLength)
.Append(dataLength)
.Append(dataTuple.Item1)
.Append(dataTuple.Item2);
pduCommand = new PDU<object>
{
data = composedData.ToString()
};
}
return pduCommand;
}
public MRS(PDU _pdu, AbstractTransport t, TransactionUser ut)
: base(t, ut)
{
pdu = _pdu;
Seq = pdu.Seq;
DeviceId = pdu.DeviceId;
}
public PDU prepareWriteRequest()
{
PDU p = new PDU();
davePrepareWriteRequest(pointer, p.pointer);
return(p);
}
protected override PDU<object> decomposePdu(PDU<object> pduInput)
{
PDU<object> pduOutput = null;
var data = pduInput.data as string;
if (data != null)
{
var composedData = new StringBuilder();
// Serialize the input
var serializer = new XmlSerializer(typeof(GameEvent));
try
{
using (var reader = new StringReader(data))
{
pduOutput = new PDU<object> {data = serializer.Deserialize(reader)};
}
}
catch (Exception ex)
{
// Todo Error handling
}
}
return pduOutput;
}
public Status CheckResponse(byte[] Response)
{
if (Response.Length < 9)
{
return(Status.Error);
}
if (
(Header.TransactionID != (Response[0] << 8) + Response[1]) ||
(Header.ProtocolID != (Response[2] << 8) + Response[3]) ||
(Header.Lenght != (Response[4] << 8) + Response[5]) ||
(Header.UnitID != Response[6]))
{
return(Status.Error);
}
if ((Response.Length == RespSize) || (Response.Length == 5))
{
var PDUResponse = new byte[Response.Length - 3];
Array.Copy(Response, 1, PDUResponse, 0, PDUResponse.Length);
return(PDU.CheckResponse(PDUResponse));
}
else
{
return(Status.Error);
}
}
protected override PDU<object> composePdu(PDU<object> pduInput)
{
PDU<object> pduOutput = null;
var data = pduInput.data as GameEvent;
if (data != null)
{
var composedData = new StringBuilder();
// Serialize the input
var serializer = new XmlSerializer(typeof (GameEvent));
try
{
using (var writer = new StringWriter(composedData))
{
serializer.Serialize(writer, data);
}
pduOutput = new PDU<object> {data = composedData.ToString()};
}
catch (Exception ex)
{
// Todo Error handling
}
}
return pduOutput;
}
public MRC(PDU _pdu, Transporte t, TransactionUser ut)
: base(t, ut)
{
pdu = _pdu;
Seq = pdu.Seq;
IdDispositivo = pdu.IdDispositivo;
Estado = Estados.INICIO;
}
public MRC(PDU _pdu, AbstractTransport t, TransactionUser ut)
: base(t, ut)
{
pdu = _pdu;
Seq = pdu.Seq;
DeviceId = pdu.DeviceId;
State = States.INICIO;
}
private void SendPDU(PDU pdu)
{
TraceSending(pdu);
var dataWriter = new BinaryDataWriter(Output, ByteOrder.BigEndian);
pdu.WriteTo(dataWriter);
Output.Flush(FlushMode.Deep);
}
public void NuevaTransaccion(Transaction t, PDU pdu)
{
if (pdu.Outgoing)
{
pdu.Seq = pdu.Destination.TomarSecuencia(t.TransactionUser);
}
trmap.Add(pdu.TransactionId, t);
}
public void Send(PDU pdu)
{
if (pdu == null)
{
throw new ArgumentNullException("pdu");
}
byte[] bytesToSend = pdu.GetBytes();
vTcpIpSession.Send(bytesToSend);
}
private bool NuevoEvento(Device d, PDU pdu, Transaccion tr)
{
d.RemoteDeviceState.LastReceivedEventData = DateTime.Now;
switch (pdu.CL)
{
case 0x20:
case 0x00:
{
//RFID Detectado.
var rfid = pdu as RFIDDetectado;
if (rfid == null)
{
return(false);
}
return(RFIDDetected != null && RFIDDetected(this, rfid));
}
case 0x11:
case 0x10:
case 0x02:
case 0x01:
{
var exv = pdu as ExcesoVelocidad;
if (exv == null)
{
return(false);
}
return(ExcesoVelocidad != null && ExcesoVelocidad(this, exv));
}
case 0xFE:
case 0xFF:
{
//Evento Generico
var evt = pdu as Evento;
if (evt == null)
{
return(false);
}
d.DeviceEvent(evt);
// ignoro los eventos de dispositivo online enviados por el dispositivo.
if (evt.CodigoEvento == (short)MessageIdentifier.DeviceOnLine_internal)
{
return(true);
}
return(Evento != null && Evento(this, evt));
}
default:
tr.CLdeRespuesta = 0x01; // codigo interino de MensajeDesconocido.
return(true);
}
}
public void TransaccionCompleta(Transaction t, PDU pdu)
{
if (trmap.ContainsKey(pdu.TransactionId))
{
if (pdu.Outgoing)
{
pdu.Destination.LiberarSecuencia(t.TransactionUser, pdu.Seq);
}
trmap.Remove(pdu.TransactionId);
}
}
private SendPDU EncodetoPDU()
{
try
{
MessageFormat mode = new MessageFormat(SMSMode.PDU);
long number;
long.TryParse(TextBoxPhoneNumberPDU.Text, out number);
PDU _pdu = new PDU();
_pdu._1stOctet = new FirstOctet
{
Message_type_indicator = TP_MTI.SMSSUBMIT,
Reject_duplicates = false,
Reply_path = (bool)CheckBoxReplyPathExist.IsChecked,
Status_report_request = (bool)CheckBoxRequestDeliveryReport.IsChecked,
User_data_header_indicator = false,
Validity_Period_Format = TP_VPI.Relative
};
if (CheckBoxFlashSMS.IsChecked == true)
{
_pdu.DataCodingScheme = TP_DSC._7bitFlashSMS;
}
else
{
_pdu.DataCodingScheme = TP_DSC._7bit;
}
if (CheckBoxRequestDeliveryReport.IsChecked == false)
{
_pdu.ValidityPeriod = -1;
}
else
{
_pdu.ValidityPeriod = ComboBoxValidityPeriodPDU.SelectedIndex;
}
_pdu.PhoneNumber = number.ToString();
_pdu.UserData = TextBoxSMSContentPDU.Text;
string result = _pdu.EncodedTextInPDU;
int lengthOfSMS = (result.Length - 2) / 2;
SendPDU sms = new SendPDU(lengthOfSMS, result);
return(sms);
}
catch (Exception ex)
{
ShowMSG(ex.Message, 5 * 1000);
return(null);
}
}
public void addPDU(PDU pdu, char[] sessionKey)
{
string sessionKeyString = new string(sessionKey);
if(isSessionAlive(sessionKeyString))
{
ScreencastingSession session = sessions[sessionKeyString];
foreach (Client client in session.authenticatedClients.Keys)
{
client.addPDU(pdu);
}
}
}
public byte[] BuildResponse()
{
var PDUResp = PDU.BuildResponse();
var Response = new byte[PDUResp.Length + 3];
PDUResp.CopyTo(Response, 1);
return(Response);
}
public override void SolicitudCancelada(PDU source, Transaccion tr, Transporte t)
{
var d = Devices.I().FindById(source.IdDispositivo);
if (d != null)
{
d.SolicitudCancelada(source);
}
else
{
STrace.Debug(typeof(ServerTU).FullName, String.Format("dispositivo no existe Id={0}", source.IdDispositivo));
}
}
public void TransaccionCompleta(Transaccion t, PDU pdu)
{
lock (trmap_lock) {
if (trmap.ContainsKey(pdu.IdTransaccion))
{
if (pdu.Saliente)
{
pdu.Destino.LiberarSecuencia(t.TransactionUser, pdu.Seq);
}
trmap.Remove(pdu.IdTransaccion);
}
}
}
public override bool Send(PDU pdu)
{
var size = 0;
// todo: que el buffer se maneje automaticamente.
var instance_buffer = new byte[1024];
T.TRACE("---SENDING-----------------------------------------------------------------");
T.TRACE(pdu.Trace(""));
T.TRACE("UDP: trid=" + pdu.TransactionId);
T.TRACE("---------------------------------------------------------------------------");
Decoder.Encode(ref instance_buffer, ref size, pdu);
return(sendTo(instance_buffer, size, pdu.Destination.UDP));
}
public override void ReceivedPDU(PDU p)
{
if (State == States.CONFIRMANDO)
{
Transport.Send(rta);
}
else if (State == States.RESPONDIENDO)
{
if (p.CH != pdu.CH)
{
State = States.TERMINADO;
TransactionUser.RespuestaEntregada(p, this, Transport);
Transport.TransaccionCompleta(this, pdu);
}
}
}
public void KeepAlive(AbstractTransport t, Destination address)
{
T.TRACE(0, "Solicitando keep alive.");
var pdu = new PDU
{
CH = (byte)Decoder.ComandoH.KeepAlive,
DeviceId = IdDispositivo,
Transport = t,
Destination = address,
};
var keep_alive_mrc = new MRC(pdu, pdu.Transport, this);
pdu.Transport.NuevaTransaccion(keep_alive_mrc, pdu);
keep_alive_mrc.Seq = pdu.Seq;
keep_alive_mrc.Start();
}
public byte[] BuildRequest()
{
var Request = new byte[ReqSize];
Request[0] = (byte)(Device as RTU_Device).Address;
var PDUReq = PDU.BuildRequest();
PDUReq.CopyTo(Request, 1);
var crc = CRC.Get(Request, PDUReq.Length + 1);
Request[PDUReq.Length + 1] = ((byte)(crc & 0xFF));
Request[PDUReq.Length + 2] = ((byte)(crc >> 8));
return(Request);
}
/// <summary>
/// Initializes a new instance of the <see cref="SnmpTrapV2C"/> class.
/// </summary>
/// <param name="bytes">The snmp encoded bytes.</param>
public SnmpTrapV2C(byte[] bytes)
: base(bytes.ToSnmpDatagram())
{
TrapOid = default(ObjectIdentifier);
SysUpTime = 0;
VarBind varBind;
if (PDU.SearchFirstSubOidWith(sysUpTimeOid, out varBind) && varBind.Asn1TypeInfo.Asn1SnmpTagType == Asn1SnmpTag.TimeTicks)
{
SysUpTime = (uint)varBind.Value;
}
if (PDU.SearchFirstSubOidWith(trapOid, out varBind) && varBind.Asn1TypeInfo.Asn1TagType == Asn1Tag.ObjectIdentifier)
{
TrapOid = (ObjectIdentifier)varBind.Value;
}
}
public byte[] BuildResponse()
{
var PDUResp = PDU.BuildResponse();
var Response = new byte[PDUResp.Length + 3];
Response[0] = (byte)(Device as RTU_Device).Address;
PDUResp.CopyTo(Response, 1);
var crc = CRC.Get(Response, PDUResp.Length + 1);
Response[PDUResp.Length + 1] = ((byte)(crc & 0xFF));
Response[PDUResp.Length + 2] = ((byte)(crc >> 8));
return(Response);
}
public override bool Send(PDU pdu)
{
var d = Devices.I().FindById(pdu.IdDispositivo);
if (d != null && d.State == DeviceTypes.States.ONLINE)
{
d.Touch(pdu.Destino);
}
if (d != null && d.SupportsChecksum)
{
pdu.Options = 0x80;
}
var size = 0;
var instance_buffer = new byte[8192];
CODEC.Encode(ref instance_buffer, ref size, pdu);
return(sendTo(instance_buffer, size, pdu.Destino.UDP));
}
/// <summary>
/// Move robot usign both motors, left and right
/// </summary>
/// <param name="left"></param>
/// <param name="right"></param>
public void Drive(int left, int right)
{
if (this.protocol != null)
{
try
{
var keyValue = new Tuple<string, string>("drive", left + "," + right);
var pduObj = new PDU<object> {data = keyValue};
if (!this.protocol.send(pduObj))
{
// error - could not send data
}
}
catch (Exception ex)
{
}
}
}
/// <summary>
/// Send data via transport layer (serial) to robot
/// </summary>
/// <param name="pdu"></param>
/// <returns></returns>
public override bool send(PDU<object> pdu)
{
var result = false;
var pduInput = composePdu(pdu);
if (pduInput == null || pduInput.data == null) return false;
try
{
this.serialPort.Write(pduInput.data.ToString());
result = true;
}
catch (Exception ex)
{
MessageBox.Show("ERROR - " + ex.Message);
}
return result;
}
protected override PDU<object> composePdu(PDU<object> pduInput)
{
if (pduInput == null)
{
return null;
}
var pduOutput = new PDU<object>();
// Get the string from the above layers
var data = pduInput.data as string;
if (data == null)
{
return null;
}
var byteData = GetBytes(data);
for (var i = 0; i < byteData.Count; i++)
{
var b = byteData[i];
// Replace all END characters with ESC_END
if (b == SLIP_END)
{
byteData[i] = SLIP_ESC;
byteData.Insert(i + 1, SLIP_ESC_END);
}
// Replace all ESC characters with ESC_ESC
if (b == SLIP_ESC)
{
byteData[i] = SLIP_ESC;
byteData.Insert(i + 1, SLIP_ESC_ESC);
}
}
// Add the END character to the end
byteData.Add(SLIP_END);
var array = byteData.ToArray();
pduOutput.data = array;
return pduOutput;
}
public static IEnumerable<PDU> ParseSnmp(this IEnumerable<Block> capture)
{
int unreadablePackets = 0; // for debugging
foreach (UdpDatagram p in capture.ParseUdp())
{
PDU pdu = null;
try
{
pdu = new PDU(p);
}
catch (Exception ex)
{
unreadablePackets++;
continue;
}
yield return pdu;
}
}
/// <summary>
/// Decompose PDU
/// </summary>
/// <param name="pduInput"></param>
protected override PDU<object> decomposePdu(PDU<object> pduInputData)
{
PDU<object> pdu = new PDU<object>();
Tuple<string, string> pduDecomposed = null;
if (pduInputData != null && pduInputData.data != null)
{
var pduInput = new string( (char[]) pduInputData.data).TrimEnd('\0');
var version = pduInput.Substring(0, 2);
var keyLength = int.Parse(pduInput.Substring(2, 3));
var dataLength = int.Parse(pduInput.Substring(5, 3));
var key = pduInput.Substring(8, keyLength);
var commandValue = pduInput.Substring(8 + keyLength, dataLength);
pduDecomposed = new Tuple<string, string>(key, commandValue);
}
pdu.data = pduDecomposed;
return pdu;
}
public override PDU<object> receive()
{
var receivedData = new List<byte>();
while (true)
{
var data = _client.Read();
if (data != null)
{
receivedData.Add((byte) data);
// Completed reading?
if ((byte) data == SLIP_END)
{
break;
}
}
}
var pdu = new PDU<object>() {data = receivedData};
return decomposePdu(pdu);
}
protected override PDU<object> decomposePdu(PDU<object> pduInput)
{
return pduInput;
}
public int getMessage(PDU p)
{
return daveSendMessage(pointer, p.pointer);
}
public int daveRecieveData(out byte[] data, out byte[] param)
{
int res = 0;
if (IntPtr.Size == 8)
res = daveGetResponse64(pointer);
else
res = daveGetResponse32(pointer);
PDU myPDU = new PDU();
if (IntPtr.Size == 8)
_daveSetupReceivedPDU64(pointer, myPDU.pointer);
else
_daveSetupReceivedPDU32(pointer, myPDU.pointer);
byte[] tmp1 = new byte[65536];
byte[] tmp2 = new byte[65536];
int ltmp1 = 0;
int ltmp2 = 0;
if (IntPtr.Size == 8)
res = daveGetPDUData64(pointer, myPDU.pointer, tmp1, ref ltmp1, tmp2, ref ltmp2);
else
res = daveGetPDUData32(pointer, myPDU.pointer, tmp1, ref ltmp1, tmp2, ref ltmp2);
data = new byte[ltmp1];
param = new byte[ltmp2];
Array.Copy(tmp1, data, ltmp1);
Array.Copy(tmp2, param, ltmp2);
return res;
}
public int daveBuildAndSendPDU(PDU myPDU, byte[] Parameter, byte[] Data)
{
int res = 0;
if (IntPtr.Size == 8)
res = daveBuildAndSendPDU64(pointer, myPDU.pointer, Parameter, Parameter.Length, Data, Data.Length);
else
res = daveBuildAndSendPDU32(pointer, myPDU.pointer, Parameter, Parameter.Length, Data, Data.Length);
//return p;
return res;
}
public PDU prepareWriteRequest()
{
PDU p = new PDU();
if (IntPtr.Size == 8)
davePrepareWriteRequest64(pointer, p.pointer);
else
davePrepareWriteRequest32(pointer, p.pointer);
return p;
}
public int execWriteRequest(PDU p, resultSet rl)
{
if (IntPtr.Size == 8)
return daveExecWriteRequest64(pointer, p.pointer, rl.pointer);
return daveExecWriteRequest32(pointer, p.pointer, rl.pointer);
}
protected override PDU<object> decomposePdu(PDU<object> pduInput)
{
if (pduInput == null)
{
return null;
}
var pduOutput = new PDU<object>();
// Get the string from the bottom layers
var data = pduInput.data as List<byte>;
if (data == null)
{
return null;
}
// Remove the END character from the end
data.RemoveAt(data.Count - 1);
for (var i = 0; i < data.Count; i++)
{
var b = data[i];
// Replace all two bytes sequences ESC ESC_ESC with the ESC character
if (b == SLIP_ESC_ESC && i > 0 && data[i - 1] == SLIP_ESC)
{
data[i] = SLIP_ESC;
data.RemoveAt(i - 1);
}
// Replace all two bytes sequences ESC ESC_END with the END character
if (b == SLIP_ESC_END && i > 0 && data[i - 1] == SLIP_ESC)
{
data[i] = SLIP_END;
data.RemoveAt(i - 1);
}
}
pduOutput.data = GetString(data.ToArray());
return pduOutput;
}
/// <summary>
/// Asynchronously send single PDU.
/// </summary>
/// <param name="pdu">PDU to send.</param>
/// <returns>Awaitable task.</returns>
protected async Task SendPDUAsync(PDU pdu)
{
while (this._pduQueue.Count >= this.MaximumPDUsInQueue)
{
await Task.Delay(10).ConfigureAwait(false);
}
lock (this._lock)
{
this._pduQueue.Enqueue(pdu);
}
await this.SendNextPDUAsync().ConfigureAwait(false);
}
public int execWriteRequest(PDU p, resultSet rl)
{
return daveExecWriteRequest(pointer, p.pointer, rl.pointer);
}
protected void SendPDU(PDU pdu) {
// throttle queueing of PDUs to prevent out of memory errors for very large datasets
do {
if (_pduQueue.Count >= MaximumPDUsInQueue) {
Thread.Sleep(10);
continue;
}
lock (_lock)
_pduQueue.Enqueue(pdu);
break;
} while (true);
SendNextPDU();
}
public PDU prepareWriteRequest()
{
PDU p=new PDU();
davePrepareWriteRequest(pointer, p.pointer);
return p;
}
public int daveGetPDUData(PDU myPDU, out byte[] data, out byte[] param)
{
byte[] tmp1 = new byte[65536];
byte[] tmp2 = new byte[65536];
int ltmp1 = 0;
int ltmp2 = 0;
int res = 0;
if (IntPtr.Size == 8)
res = daveGetPDUData64(pointer, myPDU.pointer, tmp1, ref ltmp1, tmp2, ref ltmp2);
else
res = daveGetPDUData32(pointer, myPDU.pointer, tmp1, ref ltmp1, tmp2, ref ltmp2);
data = new byte[ltmp1];
param = new byte[ltmp2];
Array.Copy(tmp1, data, ltmp1);
Array.Copy(tmp2, param, ltmp2);
return res;
}
/// <summary>
/// Asynchronously send single PDU.
/// </summary>
/// <param name="pdu">PDU to send.</param>
/// <returns>Awaitable task.</returns>
protected async Task SendPDUAsync(PDU pdu)
{
while (true)
{
lock (_lock)
{
if (_pduQueue.Count < MaximumPDUsInQueue)
{
_pduQueue.Enqueue(pdu);
break;
}
}
await Task.Delay(50).ConfigureAwait(false);
}
await SendNextPDUAsync().ConfigureAwait(false);
}
public int getMessage(PDU p)
{
if (IntPtr.Size == 8)
return daveSendMessage64(pointer, p.pointer);
else
return daveSendMessage32(pointer, p.pointer);
}
