public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length,
uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
int reading_size = 0;
if (OpenPort())
{
//очередь для поддержки делегатов в старых драйверах
Queue<byte> reading_queue = new Queue<byte>(8192);
List<byte> readBytesList = new List<byte>(8192);
try
{
//пишем в порт команду, ограниченную out_length
m_Port.Write(out_buffer, 0, out_length);
}
catch (Exception ex)
{
WriteToLog("WriteReadData: Write to port error: " + ex.Message);
}
Thread.Sleep(100);
uint elapsed_time_count = 100;
while (elapsed_time_count <= m_read_timeout)
{
if (m_Port.BytesToRead > 0)
{
try
{
byte[] tmp_buff = new byte[m_Port.BytesToRead];
int readed_bytes = m_Port.Read(tmp_buff, 0, tmp_buff.Length);
readBytesList.AddRange(tmp_buff);
}
catch (Exception ex)
{
WriteToLog("WriteReadData: Read from port error: " + ex.Message);
}
}
elapsed_time_count += 100;
Thread.Sleep(100);
}
/*TODO: Откуда взялась константа 4, почему 4?*/
if (readBytesList.Count >= 4)
{
/*попытаемся определить начало полезных данных в буфере-на-вход
при помощи связанного делегата*/
for (int i = 0; i < readBytesList.Count; i++)
reading_queue.Enqueue(readBytesList[i]);
int pos = func(reading_queue);
if (pos >= 0)
{
//избавимся от лишних данных спереди
for (int i = 0; i < pos; i++)
{
reading_queue.Dequeue();
}
//оставшиеся данные преобразуем обратно в массив
byte[] temp_buffer = new byte[reading_size = reading_queue.Count];
//WriteToLog("reading_queue.Count: " + reading_size.ToString());
temp_buffer = reading_queue.ToArray();
//WriteToLog(BitConverter.ToString(temp_buffer));
//если длина полезных данных ответа определена как 0, произведем расчет по необязательнм параметрам
if (target_in_length == 0)
{
if (reading_size > pos_count_data_size)
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
}
if (target_in_length == -1)
{
target_in_length = reading_queue.Count;
reading_size = target_in_length;
in_buffer = new byte[reading_size];
for (int i = 0; i < in_buffer.Length; i++)
in_buffer[i] = temp_buffer[i];
ClosePort();
return reading_size;
}
if (target_in_length > 0 && reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
}
}
}
}
else
{
WriteToLog("Open port Error");
}
ClosePort();
return reading_size;
}
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
int reading_size = 0;
using (TcpClient tcp = new TcpClient())
{
Queue <byte> reading_queue = new Queue <byte>(8192);
try
{
Thread.Sleep(m_delay_between_sending);
IAsyncResult ar = tcp.BeginConnect(m_address, m_port, null, null);
using (WaitHandle wh = ar.AsyncWaitHandle)
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(10), false))
{
throw new TimeoutException();
}
else
{
if (tcp.Client.Connected)
{
WriteToLog("connected");
tcp.Client.ReceiveTimeout = m_read_timeout;
tcp.Client.SendTimeout = m_write_timeout;
// посылка данных
if (tcp.Client.Send(out_buffer, out_length, SocketFlags.None) == out_length)
{
string str = String.Join(" ", out_buffer);
WriteToLog("Tx: " + str);
uint elapsed_time_count = 0;
Thread.Sleep(50);
// чтение данных
while (elapsed_time_count < m_read_timeout)
{
if (tcp.Client.Available > 0)
{
try
{
byte[] tmp_buff = new byte[tcp.Available];
int readed_bytes = tcp.Client.Receive(tmp_buff, 0, tmp_buff.Length, SocketFlags.None);
for (int i = 0; i < readed_bytes; i++)
{
reading_queue.Enqueue(tmp_buff[i]);
}
str = String.Join(" ", tmp_buff);
WriteToLog("RxCorrect: " + str);
}
catch (Exception ex)
{
WriteToLog("Receive: " + ex.Message);
}
}
elapsed_time_count += 50;
Thread.Sleep(50);
}
int pos = -1;
if ((pos = func(reading_queue)) >= 0)
{
for (int i = 0; i < pos; i++)
{
reading_queue.Dequeue();
}
byte[] temp_buffer = new byte[reading_size = reading_queue.Count];
temp_buffer = reading_queue.ToArray();
if (target_in_length == 0)
{
if (reading_size > pos_count_data_size)
{
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
}
}
if (target_in_length > 0)
{
if (reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
}
}
}
}
}
else
{
WriteToLog("Is not tcp connected");
}
}
}
}
catch (Exception ex)
{
WriteToLog(ex.Message);
return(-1);
}
finally
{
reading_queue.Clear();
}
}
return(reading_size);
}
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
int reading_size = 0;
using (TcpClient tcp = new TcpClient())
{
Queue<byte> reading_queue = new Queue<byte>(8192);
try
{
Thread.Sleep(m_delay_between_sending);
tcp.SendTimeout = 500;
tcp.ReceiveTimeout = 500;
IAsyncResult ar = tcp.BeginConnect(m_address, m_port, null, null);
using (WaitHandle wh = ar.AsyncWaitHandle)
{
if (!ar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(10), false))
{
throw new TimeoutException();
}
else
{
if (tcp.Client.Connected)
{
tcp.Client.ReceiveTimeout = m_read_timeout;
tcp.Client.SendTimeout = m_write_timeout;
// посылка данных
if (tcp.Client.Send(out_buffer, out_length, SocketFlags.None) == out_length)
{
uint elapsed_time_count = 0;
Thread.Sleep(50);
// чтение данных
while (elapsed_time_count < m_read_timeout)
{
if (tcp.Client.Available > 0)
{
try
{
byte[] tmp_buff = new byte[tcp.Available];
int readed_bytes = tcp.Client.Receive(tmp_buff, 0, tmp_buff.Length, SocketFlags.None);
for (int i = 0; i < readed_bytes; i++)
{
reading_queue.Enqueue(tmp_buff[i]);
}
}
catch (Exception ex)
{
WriteToLog("Receive: " + ex.Message);
}
}
elapsed_time_count += 50;
Thread.Sleep(50);
}
int pos = -1;
if ((pos = func(reading_queue)) >= 0)
{
for (int i = 0; i < pos; i++)
{
reading_queue.Dequeue();
}
byte[] temp_buffer = new byte[reading_size = reading_queue.Count];
temp_buffer = reading_queue.ToArray();
if (target_in_length == 0)
{
if (reading_size > pos_count_data_size)
{
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
}
}
if (target_in_length > 0)
{
if (reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
}
}
}
}
}
}
}
}
catch (Exception ex)
{
WriteToLog(ex.Message);
return -1;
}
finally
{
reading_queue.Clear();
}
}
return reading_size;
}
/// <summary>
/// Производит запись команды в COM порт и последующее чтение входных данных с учетом особенностей
/// всех драйверов
/// </summary>
/// <param name="func">Метод возвращающий int значение начала полезных данных в ответе счетчика</param>
/// <param name="out_buffer">Данные отправляемые на счетчик</param>
/// <param name="in_buffer">Полезные данные выделенные из ответа счетчика</param>
/// <param name="out_length">Длина полезных данных в массиве отправляемых на счетчик данных</param>
/// <param name="target_in_length">Ожидаемая длина полезных данных ответа счетчика. -1 если все пришедшие данные считаются полезными,
/// 0 - если для выделения полезных данных требуется использовать необязательные параметры.</param>
/// <param name="pos_count_data_size">Первый байт полезных данных ответа счетчика</param>
/// <param name="size_data">Размер полезных данных ответа</param>
/// <param name="header_size">Размер заголовка</param>
/// <returns>int количество полезных данных ответа</returns>
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length,
uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
int reading_size = 0;
if (isOpened())
{
//очередь для поддержки делегатов в старых драйверах
Queue <byte> reading_queue = new Queue <byte>(8192);
//список считываемых байт
List <byte> readBytesList = new List <byte>(8192);
#region БЛОК ЗАПИСИ В ПОРТ
try
{
//пишем в порт команду, ограниченную out_length
m_Port.Write(out_buffer, 0, out_length);
}
catch (Exception ex)
{
WriteToLog("WriteReadData: Write to port error: " + ex.Message);
return(0);
}
#endregion
#region БЛОК ЧТЕНИЯ ИЗ ПОРТА
Thread.Sleep(100);
int elapsed_time_count = 100;
while (elapsed_time_count <= m_read_timeout)
{
if (m_Port.BytesToRead > 0)
{
try
{
byte[] tmp_buff = new byte[m_Port.BytesToRead];
int read_bytes = m_Port.Read(tmp_buff, 0, tmp_buff.Length);
readBytesList.AddRange(tmp_buff);
}
catch (Exception ex)
{
WriteToLog("WriteReadData: Read from port error: " + ex.Message);
}
}
elapsed_time_count += 100;
Thread.Sleep(100);
}
#endregion
#region БЛОК РАЗБОРА ДАННЫХ
/*TODO: Откуда взялась константа 4, почему 4?*/
if (readBytesList.Count >= 4)
{
/*попытаемся определить начало полезных данных в буфере-на-вход
* при помощи связанного делегата*/
for (int i = 0; i < readBytesList.Count; i++)
{
reading_queue.Enqueue(readBytesList[i]);
}
int pos = func(reading_queue);
if (pos >= 0)
{
//избавимся от лишних данных спереди
for (int i = 0; i < pos; i++)
{
reading_queue.Dequeue();
}
//оставшиеся данные преобразуем обратно в массив
reading_size = reading_queue.Count;
byte[] temp_buffer = reading_queue.ToArray();
//WriteToLog(BitConverter.ToString(temp_buffer));
if (target_in_length == 0)
{
//если длина полезных данных ответа определена как 0, произведем расчет по необязательнм параметрам
if (reading_size > pos_count_data_size)
{
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
}
}
else if (target_in_length == -1)
{
//если как -1, считаем, что все данные пришедшие в буфер полезные
in_buffer = new byte[reading_size];
for (int i = 0; i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
return(reading_size);
}
else if (target_in_length > 0 && reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < in_buffer.Length; i++)
{
in_buffer[i] = temp_buffer[i];
}
return(reading_size);
}
}
}
#endregion
}
else
{
WriteToLog("Open port Error");
}
return(reading_size);
}
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
// Data buffer for incoming data.
byte[] bytes = new byte[1024];
List<byte> receivedBytes = new List<byte>();
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPAddress ipaddr = IPAddress.Parse(m_address.ToString());
IPEndPoint remoteEP = new IPEndPoint(ipaddr, m_port);
// Create a TCP/IP socket.
Socket sender = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
sender.ReceiveTimeout = m_read_timeout;
// Connect the socket to the remote endpoint. Catch any errors.
try
{
sender.Connect(remoteEP);
WriteToLog(String.Format("Socket connected to {0}",
sender.RemoteEndPoint.ToString()));
// Send the data through the socket.
int bytesSent = sender.Send(out_buffer);
while (true)
{
bytes = new byte[1024];
try
{
// Receive the response from the remote device.
int bytesRec = sender.Receive(bytes);
for (int i = 0; i < bytesRec; i++)
receivedBytes.Add(bytes[i]);
}
catch (Exception ex)
{
WriteToLog("Timeout");
break;
}
}
// Release the socket.
sender.Shutdown(SocketShutdown.Both);
sender.Close();
WriteToLog("Disconected from server");
}
catch (Exception exx)
{
WriteToLog("Connection exception: " + exx.Message);
}
}
catch (Exception e)
{
WriteToLog("Common exception: " + e.Message);
}
WriteToLog("Totally bytes received: " + BitConverter.ToString(receivedBytes.ToArray()).Replace("-", " "));
in_buffer = receivedBytes.ToArray();
return receivedBytes.Count;
}
public int WriteReadData(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
TimeSpan ts = DateTime.Now - dtCreated;
int tcpAliveMinutes = -1;
GetTCPPortLiveMinutes(out tcpAliveMinutes);
if (ts.TotalMinutes >= tcpAliveMinutes)
{
dtCreated = DateTime.Now;
//ReInitialize();
}
WriteToLog("write read data starts here");
List<byte> readBytesList = new List<byte>(8192);
int readingSize = 0;
try
{
for (int i = 0; i < 2; i++)
{
if (sender.Connected)
{
// Send the data through the socket.
sender.Send(out_buffer, 0, out_length, SocketFlags.None);
Thread.Sleep(10);
uint elapsed_time_count = 100;
while (elapsed_time_count <= m_read_timeout)
{
if (sender.Available > 0)
{
try
{
byte[] tmp_buff = new byte[sender.Available];
int readed_bytes = sender.Receive(tmp_buff);
readBytesList.AddRange(tmp_buff);
}
catch (Exception ex)
{
WriteToLog("WriteReadData: Read from port error: " + ex.Message);
}
}
elapsed_time_count += 100;
Thread.Sleep(100);
}
bool bManageRes = ManageUpWithReceivedBytes(readBytesList, func, target_in_length, out in_buffer, out readingSize,
pos_count_data_size, size_data, header_size);
}
else
{
if (i == 0)
ReInitialize();
else
WriteToLog("WriteReadData: ошибка соединения");
}
}
}
catch (Exception ex)
{
WriteToLog("WriteReadData: " + ex.Message);
return -1;
}
return readingSize;
}
public bool ManageUpWithReceivedBytes(List<byte> readBytesList,
FindPacketSignature func, int target_in_length,
out byte[] outDataArr, out int outReadingSize,
uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
outDataArr = new byte[target_in_length];
outDataArr[0] = 0x0;
outReadingSize = 0;
//очередь для поддержки делегатов в старых драйверах
Queue<byte> reading_queue = new Queue<byte>(8192);
int reading_size = 0;
if (readBytesList.Count > 0)
{
/*попытаемся определить начало полезных данных в буфере-на-вход
при помощи связанного делегата*/
for (int i = 0; i < readBytesList.Count; i++)
reading_queue.Enqueue(readBytesList[i]);
int pos = func(reading_queue);
if (pos >= 0)
{
//избавимся от лишних данных спереди
for (int i = 0; i < pos; i++)
reading_queue.Dequeue();
//оставшиеся данные преобразуем обратно в массив
byte[] temp_buffer = new byte[reading_size = reading_queue.Count];
//WriteToLog("reading_queue.Count: " + reading_size.ToString());
temp_buffer = reading_queue.ToArray();
//WriteToLog(BitConverter.ToString(temp_buffer));
//если длина полезных данных ответа определена как 0, произведем расчет по необязательнм параметрам
if (target_in_length == 0)
{
if (reading_size > pos_count_data_size)
target_in_length = Convert.ToInt32(temp_buffer[pos_count_data_size] * size_data + header_size);
outReadingSize = reading_size;
return true;
}
if (target_in_length == -1)
{
target_in_length = reading_queue.Count;
reading_size = target_in_length;
outDataArr = new byte[reading_size];
for (int i = 0; i < outDataArr.Length; i++)
outDataArr[i] = temp_buffer[i];
outReadingSize = reading_size;
return true;
}
if (target_in_length > 0 && reading_size >= target_in_length)
{
reading_size = target_in_length;
for (int i = 0; i < target_in_length && i < outDataArr.Length; i++)
outDataArr[i] = temp_buffer[i];
outReadingSize = reading_size;
return true;
}
}
}
return false;
}
public int WriteReadData3(FindPacketSignature func, byte[] out_buffer, ref byte[] in_buffer, int out_length, int target_in_length, uint pos_count_data_size = 0, uint size_data = 0, uint header_size = 0)
{
// Data buffer for incoming data.
byte[] bytes = new byte[1024];
List <byte> receivedBytes = new List <byte>();
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPAddress ipaddr = IPAddress.Parse(m_address.ToString());
IPEndPoint remoteEP = new IPEndPoint(ipaddr, m_port);
// Create a TCP/IP socket.
Socket sender = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
sender.ReceiveTimeout = m_read_timeout;
// Connect the socket to the remote endpoint. Catch any errors.
try
{
sender.Connect(remoteEP);
WriteToLog(String.Format("Socket connected to {0}",
sender.RemoteEndPoint.ToString()));
// Send the data through the socket.
int bytesSent = sender.Send(out_buffer);
while (true)
{
bytes = new byte[1024];
try
{
// Receive the response from the remote device.
int bytesRec = sender.Receive(bytes);
for (int i = 0; i < bytesRec; i++)
{
receivedBytes.Add(bytes[i]);
}
}
catch (Exception ex)
{
WriteToLog("Timeout");
break;
}
}
// Release the socket.
sender.Shutdown(SocketShutdown.Both);
sender.Close();
WriteToLog("Disconected from server");
}
catch (Exception exx)
{
WriteToLog("Connection exception: " + exx.Message);
}
}
catch (Exception e)
{
WriteToLog("Common exception: " + e.Message);
}
WriteToLog("Totally bytes received: " + BitConverter.ToString(receivedBytes.ToArray()).Replace("-", " "));
in_buffer = receivedBytes.ToArray();
return(receivedBytes.Count);
}
