Example #1
0
        /// <summary>
        /// Считать данные с условиями остановки чтения
        /// </summary>
        public override int Read(byte[] buffer, int offset, int maxCount, int timeout, Connection.BinStopCondition stopCond, 
            out bool stopReceived, CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);

                stopReceived = false;
                byte stopCode = stopCond.StopCode;
                int curInd = offset;
                SerialPort.ReadTimeout = 0;

                while (readCnt <= maxCount && !stopReceived && startDT <= nowDT && nowDT <= stopDT)
                {
                    bool readOk;
                    try { readOk = SerialPort.Read(buffer, curInd, 1) > 0; }
                    catch (TimeoutException) { readOk = false; }

                    if (readOk)
                    {
                        stopReceived = buffer[curInd] == stopCode;
                        curInd++;
                        readCnt++;
                    }
                    else
                    {
                        // накопление входных данных в буфере порта
                        Thread.Sleep(DataAccumThreadDelay);
                    }

                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, readCnt, logFormat);
                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataWithStopCondError + ": " + ex.Message, ex);
            }
        }
Example #2
0
 /// <summary>
 /// Считать данные с условиями остановки чтения
 /// </summary>
 public abstract int Read(byte[] buffer, int offset, int maxCount, int timeout, BinStopCondition stopCond,
     out bool stopReceived, CommUtils.ProtocolLogFormats logFormat, out string logText);
Example #3
0
 /// <summary>
 /// Записать данные
 /// </summary>
 public abstract void Write(byte[] buffer, int offset, int count,
     CommUtils.ProtocolLogFormats logFormat, out string logText);
Example #4
0
 /// <summary>
 /// Сформировать текст записи данных для вывода в журнал
 /// </summary>
 public static string BuildWriteLogText(byte[] buffer, int offset, int count, 
     CommUtils.ProtocolLogFormats logFormat)
 {
     return CommPhrases.SendNotation + " (" + count + "): " +
         (logFormat == CommUtils.ProtocolLogFormats.Hex ?
             CommUtils.BytesToHex(buffer, offset, count) :
             CommUtils.BytesToString(buffer, offset, count));
 }
Example #5
0
 /// <summary>
 /// Считать данные
 /// </summary>
 /// <returns>Количество считанных байт</returns>
 public abstract int Read(byte[] buffer, int offset, int count, int timeout,
     CommUtils.ProtocolLogFormats logFormat, out string logText);
Example #6
0
        /// <summary>
        /// Считать данные с условиями остановки чтения
        /// </summary>
        public override int Read(byte[] buffer, int offset, int maxCount, int timeout, BinStopCondition stopCond, 
            out bool stopReceived, CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);
                IPEndPoint endPoint = CreateIPEndPoint();

                stopReceived = false;
                byte stopCode = stopCond.StopCode;
                UdpClient.Client.ReceiveTimeout = DatagramReceiveTimeout;

                while (readCnt < maxCount && !stopReceived && startDT <= nowDT && nowDT <= stopDT)
                {
                    // считывание данных
                    int readPos;
                    bool isNew;
                    byte[] datagram = ReceiveDatagram(ref endPoint, out readPos, out isNew);

                    if (datagram != null && datagram.Length > 0)
                    {
                        // поиск кода остановки в считанных данных
                        int datagramLen = datagram.Length;
                        int stopCodeInd = -1;
                        for (int i = readPos; i < datagramLen && !stopReceived; i++)
                        {
                            if (datagram[i] == stopCode)
                            {
                                stopCodeInd = i;
                                stopReceived = true;
                            }
                        }

                        // копирование полученных данных в заданный буфер
                        int requiredCnt = stopReceived ? stopCodeInd - readCnt + 1 : maxCount - readCnt;
                        int copyCnt = Math.Min(datagram.Length - readPos, requiredCnt);
                        Array.Copy(datagram, readPos, buffer, readCnt, copyCnt);
                        readCnt += copyCnt;
                        readPos += copyCnt;
                    }

                    // накопление данных во внутреннем буфере соединения
                    if (readCnt < maxCount && !stopReceived && isNew)
                        Thread.Sleep(DataAccumThreadDelay);

                    StoreDatagram(datagram, readPos);
                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, readCnt, logFormat);
                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataWithStopCondError + ": " + ex.Message, ex);
            }
        }
Example #7
0
 /// <summary>
 /// Сформировать текст считывания данных для вывода в журнал
 /// </summary>
 public static string BuildReadLogText(byte[] buffer, int offset, int readCnt,
     CommUtils.ProtocolLogFormats logFormat)
 {
     return CommPhrases.ReceiveNotation + " (" + readCnt + "): " +
         (logFormat == CommUtils.ProtocolLogFormats.Hex ?
             CommUtils.BytesToHex(buffer, offset, readCnt) :
             CommUtils.BytesToString(buffer, offset, readCnt));
 }
Example #8
0
        /// <summary>
        /// Считать данные с условием остановки чтения
        /// </summary>
        public override int Read(byte[] buffer, int offset, int maxCount, int timeout, BinStopCondition stopCond,
            out bool stopReceived, CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);
                NetStream.ReadTimeout = OneByteReadTimeout;

                stopReceived = false;
                int curOffset = offset;
                byte stopCode = stopCond.StopCode;

                while (readCnt < maxCount && !stopReceived && startDT <= nowDT && nowDT <= stopDT)
                {
                    // считывание одного байта данных
                    bool readOk;
                    try { readOk = NetStream.Read(buffer, curOffset, 1) > 0; }
                    catch (IOException) { readOk = false; }

                    if (readOk)
                    {
                        stopReceived = buffer[curOffset] == stopCode;
                        curOffset++;
                        readCnt++;
                    }
                    else
                    {
                        // накопление данных во внутреннем буфере соединения
                        Thread.Sleep(DataAccumThreadDelay);
                    }

                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, readCnt, logFormat);

                if (readCnt > 0)
                    UpdateActivityDT();

                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataWithStopCondError + ": " + ex.Message, ex);
            }
        }
Example #9
0
        /// <summary>
        /// Считать данные, доступные на текущий момент
        /// </summary>
        public int ReadAvailable(byte[] buffer, int offset, CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int count = TcpClient.Available;
                int readCnt = NetStream.Read(buffer, offset, count);
                logText = BuildReadLogText(buffer, offset, count, readCnt, logFormat);

                if (readCnt > 0)
                    UpdateActivityDT();

                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadAvailableError + ": " + ex.Message, ex);
            }
        }
Example #10
0
 /// <summary>
 /// Считать данные из последовательного порта
 /// </summary>
 /// <param name="serialPort">Последовательный порт</param>
 /// <param name="buffer">Буфер принимаемых данных</param>
 /// <param name="index">Начальный индекс в буфере</param>
 /// <param name="maxCount">Максимальное количество принимаемых байт</param>
 /// <param name="stopCode">Байт, означающий окончание считывания данных</param>
 /// <param name="timeout">Таймаут чтения данных, мс</param>
 /// <param name="wait">Ожидать завершения таймаута после окончания чтения</param>
 /// <param name="logFormat">Формат вывода данных в журнал</param>
 /// <param name="logText">Строка для вывода в журнал</param>
 /// <returns>Количество считанных байт</returns>
 public static int ReadFromSerialPort(SerialPort serialPort, byte[] buffer, int index, int maxCount,
     byte stopCode, int timeout, bool wait /*игнорируется*/, CommUtils.ProtocolLogFormats logFormat, 
     out string logText)
 {
     try
     {
         if (serialPort == null)
         {
             logText = ReadDataImpossible;
             return 0;
         }
         else
         {
             serialConn.SetSerialPort(serialPort);
             bool stopReceived;
             return serialConn.Read(buffer, index, maxCount, timeout, new Connection.BinStopCondition(stopCode),
                 out stopReceived, logFormat, out logText);
         }
     }
     catch (Exception ex)
     {
         logText = ex.Message;
         return 0;
     }
 }
Example #11
0
        /// <summary>
        /// Считать данные
        /// </summary>
        public override int Read(byte[] buffer, int offset, int count, int timeout, 
            CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);
                NetStream.ReadTimeout = timeout; // таймаут не выдерживается, если считаны все доступные данные

                while (readCnt < count && startDT <= nowDT && nowDT <= stopDT)
                {
                    // считывание данных
                    try { readCnt += NetStream.Read(buffer, readCnt + offset, count - readCnt); }
                    catch (IOException) { }

                    // накопление данных во внутреннем буфере соединения
                    if (readCnt < count)
                        Thread.Sleep(DataAccumThreadDelay);

                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, count, readCnt, logFormat);

                if (readCnt > 0)
                    UpdateActivityDT();

                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataError + ": " + ex.Message, ex);
            }
        }
Example #12
0
 /// <summary>
 /// Считать данные из последовательного порта
 /// </summary>
 /// <param name="serialPort">Последовательный порт</param>
 /// <param name="buffer">Буфер принимаемых данных</param>
 /// <param name="index">Начальный индекс в буфере</param>
 /// <param name="count">Количество принимаемых байт</param>
 /// <param name="timeout">Таймаут чтения данных, мс</param>
 /// <param name="wait">Ожидать завершения таймаута после окончания чтения</param>
 /// <param name="logFormat">Формат вывода данных в журнал</param>
 /// <param name="logText">Строка для вывода в журнал</param>
 /// <returns>Количество считанных байт</returns>
 public static int ReadFromSerialPort(SerialPort serialPort, byte[] buffer, int index, int count,
     int timeout, bool wait /*игнорируется*/, CommUtils.ProtocolLogFormats logFormat, out string logText)
 {
     try
     {
         if (serialPort == null)
         {
             logText = ReadDataImpossible;
             return 0;
         }
         else
         {
             serialConn.SetSerialPort(serialPort);
             return serialConn.Read(buffer, index, count, timeout, logFormat, out logText);
         }
     }
     catch (Exception ex)
     {
         logText = ex.Message;
         return 0;
     }
 }
Example #13
0
 /// <summary>
 /// Записать данные в последовательный порт
 /// </summary>
 /// <param name="serialPort">Последовательный порт</param>
 /// <param name="buffer">Буфер передаваемых данных</param>
 /// <param name="index">Начальный индекс в буфере</param>
 /// <param name="count">Количество передаваемых байт</param>
 /// <param name="logFormat">Формат вывода данных в журнал</param>
 /// <param name="logText">Строка для вывода в журнал</param>
 public static void WriteToSerialPort(SerialPort serialPort, byte[] buffer, int index, int count,
     CommUtils.ProtocolLogFormats logFormat, out string logText)
 {
     try
     {
         if (serialPort == null)
         {
             logText = WriteDataImpossible;
         }
         else
         {
             serialConn.SetSerialPort(serialPort);
             serialConn.Write(buffer, index, count, logFormat, out logText);
         }
     }
     catch (Exception ex)
     {
         logText = ex.Message;
     }
 }
Example #14
0
        /// <summary>
        /// Записать данные
        /// </summary>
        public override void Write(byte[] buffer, int offset, int count, 
            CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                if (string.IsNullOrEmpty(RemoteAddress))
                    throw new InvalidOperationException("RemoteAddress is undefined.");
                if (RemotePort <= 0)
                    throw new InvalidOperationException("RemotePort is undefined.");

                byte[] datagram;
                if (offset > 0)
                {
                    datagram = new byte[count];
                    Array.Copy(buffer, offset, datagram, 0, count);
                }
                else
                {
                    datagram = buffer;
                }

                try
                {
                    int sentCnt = UdpClient.Send(datagram, count, RemoteAddress, RemotePort);
                    logText = BuildWriteLogText(datagram, 0, count, logFormat);
                }
                catch (SocketException ex)
                {
                    logText = CommPhrases.WriteDataError + ": " + ex.Message;
                }
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.WriteDataError + ": " + ex.Message, ex);
            }
        }
Example #15
0
        /// <summary>
        /// Записать данные
        /// </summary>
        public override void Write(byte[] buffer, int offset, int count, 
            CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                SerialPort.DiscardInBuffer();
                SerialPort.DiscardOutBuffer();

                try
                {
                    SerialPort.Write(buffer, offset, count);
                    logText = BuildWriteLogText(buffer, offset, count, logFormat);
                }
                catch (TimeoutException ex)
                {
                    logText = CommPhrases.WriteDataError + ": " + ex.Message;
                }
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.WriteDataError + ": " + ex.Message, ex);
            }
        }
Example #16
0
 /// <summary>
 /// Записать данные
 /// </summary>
 public override void Write(byte[] buffer, int offset, int count,
     CommUtils.ProtocolLogFormats logFormat, out string logText)
 {
     try
     {
         NetStream.Write(buffer, offset, count);
         logText = BuildWriteLogText(buffer, offset, count, logFormat);
     }
     catch (IOException ex)
     {
         logText = CommPhrases.WriteDataError + ": " + ex.Message;
     }
     catch (Exception ex)
     {
         throw new InvalidOperationException(CommPhrases.WriteDataError + ": " + ex.Message, ex);
     }
 }
Example #17
0
        /// <summary>
        /// Считать данные
        /// </summary>
        public override int Read(byte[] buffer, int offset, int count, int timeout, 
            CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                // данный способ чтения данных необходим для избежания исключения 
                // System.ObjectDisposedException при прерывании потока линии связи
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);
                SerialPort.ReadTimeout = 0;

                while (readCnt < count && startDT <= nowDT && nowDT <= stopDT)
                {
                    try { readCnt += SerialPort.Read(buffer, offset + readCnt, count - readCnt); }
                    catch (TimeoutException) { }

                    // накопление входных данных в буфере порта
                    if (readCnt < count)
                        Thread.Sleep(DataAccumThreadDelay);

                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, count, readCnt, logFormat);
                return readCnt;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataError + ": " + ex.Message, ex);
            }
        }
Example #18
0
        /// <summary>
        /// Считать данные
        /// </summary>
        public override int Read(byte[] buffer, int offset, int count, int timeout, 
            CommUtils.ProtocolLogFormats logFormat, out string logText)
        {
            try
            {
                int readCnt = 0;
                DateTime nowDT = DateTime.Now;
                DateTime startDT = nowDT;
                DateTime stopDT = startDT.AddMilliseconds(timeout);
                IPEndPoint endPoint = CreateIPEndPoint();
                UdpClient.Client.ReceiveTimeout = DatagramReceiveTimeout;

                while (readCnt < count && startDT <= nowDT && nowDT <= stopDT)
                {
                    // считывание данных
                    int readPos;
                    bool isNew;
                    byte[] datagram = ReceiveDatagram(ref endPoint, out readPos, out isNew);

                    // копирование полученных данных в заданный буфер
                    if (datagram != null && datagram.Length > 0)
                    {
                        int requiredCnt = count - readCnt;
                        int copyCnt = Math.Min(datagram.Length - readPos, requiredCnt);
                        Array.Copy(datagram, readPos, buffer, readCnt, copyCnt);
                        readCnt += copyCnt;
                        readPos += copyCnt;
                    }

                    // накопление данных во внутреннем буфере соединения
                    if (readCnt < count && isNew)
                        Thread.Sleep(DataAccumThreadDelay);

                    StoreDatagram(datagram, readPos);
                    nowDT = DateTime.Now;
                }

                logText = BuildReadLogText(buffer, offset, count, readCnt, logFormat);
                return readCnt;
            }
            catch (SocketException ex)
            {
                logText = CommPhrases.ReadDataError + ": " + ex.Message;
                return 0;
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(CommPhrases.ReadDataError + ": " + ex.Message, ex);
            }
        }