Example #1
0
        public void WriteData(string input, FrameType type)
        //пока считаем, что input строка символов
        {
            byte[] Header = { STARTBYTE, (byte)type };
            byte[] BufferToSend;
            byte[] Telegram;

            //Я добавил:
            //byte[] Header = { STARTBYTE, receiver, (byte)type, sender };
            //byte[] BufferToSend;
            byte[] spd;
            byte[] size;
            byte[] ByteToEncode;
            byte[] ByteEncoded;
            byte[] NumOfFrames;
            byte[] fileId = { 0 };
            int    i;

            switch (type)
            {
            case FrameType.MSG:
                #region MSG
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram = Encoding.Default.GetBytes(input);              //потом это кыш

                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Log.AppendText("(" + Port.PortName + ") WriteData: sent message >  " + Encoding.Default.GetString(Telegram) + "\n");
                }
                break;
                #endregion


            case FrameType.FILE:
                #region FILE
                if (IsConnected())
                {
                    ByteToEncode = File.ReadAllBytes(@input);
                    size         = new byte[10];
                    //MessageBox.Show(((double)ByteToEncode.Length / 1048576).ToString());
                    size = Encoding.Unicode.GetBytes(((double)ByteToEncode.Length / 1024).ToString());     //1048576 байт = 1 Мбайт
                    //size = Encoding.Default.GetBytes((input.Length).ToString());
                    ByteEncoded = new byte[ByteToEncode.Length * 2];
                    i           = 0;

                    string typeFile = @input.Split('.')[1];
                    fileId[0] = TypeFile_to_IdFile(typeFile);

                    Display.AppendText("Длина ByteToEncode:" + ByteToEncode.Length + "\n");
                    foreach (byte item in ByteToEncode)
                    {
                        Hamming.HammingEncode74(ByteToEncode[i]).CopyTo(ByteEncoded, i * 2);
                        i++;
                        //Display.AppendText(i / ByteToEncode.Length * 100 + ", ");


                        //loading.progressBar1.Increment(i / ByteToEncode.Length * 100);
                    }
                    //double parts;

                    //parts = (int)Math.Ceiling((double)ByteEncoded.Length / (double)(Port.WriteBufferSize - Header.Length - fileId.Length - 10));
                    //NumOfFrames = Encoding.Unicode.GetBytes((parts).ToString());
                    if (Header.Length + fileId.Length + ByteEncoded.Length + 8 < Port.WriteBufferSize)
                    {
                        BufferToSend = new byte[Header.Length + fileId.Length + 10 + ByteEncoded.Length];    //!
                        Header.CopyTo(BufferToSend, 0);
                        fileId.CopyTo(BufferToSend, Header.Length);
                        size.CopyTo(BufferToSend, Header.Length + fileId.Length);
                        //NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + size.Length);
                        ByteEncoded.CopyTo(BufferToSend, Header.Length + fileId.Length + 10 /*+ NumOfFrames.Length*/);    //!
                        bool flag = false;
                        while (!flag)
                        {
                            //Application.DoEvents();
                            if (MessageBox.Show("Send?", "Test", MessageBoxButtons.YesNo) == DialogResult.Yes)
                            {
                                flag = true;
                                Port.Write(BufferToSend, 0, BufferToSend.Length);
                                //loading.Hide();
                                MessageBox.Show("Готово!");
                                //loading.progressBar1.Value = 0;
                                //loading.i = 1;
                            }
                            else
                            {
                                flag = true;
                                //loading.Hide();
                                //loading.progressBar1.Value = 0;
                                MessageBox.Show("Вы отменили передачу файла.");
                                // loading.i = 1;
                            }
                        }
                    }
                    else
                    {
                        double parts;
                        int    EncodedByteIndex;
                        int    Part_ByteEncodedIndex;
                        parts = (double)ByteEncoded.Length / (double)(Port.WriteBufferSize - Header.Length - fileId.Length - 10);
                        MessageBox.Show(Port.WriteBufferSize.ToString() + " " + parts.ToString() + ((int)Math.Ceiling(parts)).ToString());
                        for (i = 0; i <= (int)Math.Ceiling(parts); i++)
                        {
                            BufferToSend = new byte[Port.WriteBufferSize];    //!
                            Header.CopyTo(BufferToSend, 0);
                            fileId.CopyTo(BufferToSend, Header.Length);
                            size.CopyTo(BufferToSend, Header.Length + fileId.Length);
                            byte[] Part_ByteEncoded;
                            byte[] Last_Part;
                            Part_ByteEncoded      = new byte[Port.WriteBufferSize - Header.Length - fileId.Length];
                            EncodedByteIndex      = i * (Port.WriteBufferSize - Header.Length - fileId.Length);
                            Part_ByteEncodedIndex = (Port.WriteBufferSize - Header.Length - fileId.Length);
                            if (((ByteEncoded.Length - EncodedByteIndex) >= Part_ByteEncodedIndex))
                            {
                                Array.ConstrainedCopy(ByteEncoded, EncodedByteIndex, Part_ByteEncoded, 0, Part_ByteEncodedIndex);
                                Part_ByteEncoded.CopyTo(BufferToSend, Header.Length + fileId.Length);    //!
                            }
                            else if (ByteEncoded.Length - EncodedByteIndex > 0)
                            {
                                Last_Part = new byte [ByteEncoded.Length - i * Port.WriteBufferSize];
                                Last_Part.CopyTo(BufferToSend, Header.Length + fileId.Length);    //!
                            }

                            Port.Write(BufferToSend, 0, BufferToSend.Length);
                        }
                    }
                }
                break;
                #endregion

            default:
                if (IsConnected())
                {
                    Port.Write(Header, 0, Header.Length);
                }
                break;
            }

            //Зачем такая конструкция?
            Log.Invoke(new EventHandler(delegate
            {
                Log.AppendText("sent frame " + type + "\n"); //всё записываем, мы же снобы
            }));
        }
Example #2
0
        public void WriteData(string input, FrameType type)
        {
            byte[] Header = { STARTBYTE, (byte)type };

            byte[] fileId = { 0 };
            byte[] size;
            byte[] NumOfFrames;
            byte[] FrameNumber;

            byte[] BufferToSend;
            byte[] Telegram;
            string Telegram_s;
            string size_s;

            byte[] ByteToEncode;
            byte[] ByteEncoded;


            switch (type)
            {
            case FrameType.ERR_FILE:


                break;

            case FrameType.MSG:

                #region MSG
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram = Encoding.Default.GetBytes(input);              //потом это кыш

                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Log.AppendText("(" + Port.PortName + ") WriteData: sent message >  " + Encoding.Default.GetString(Telegram) + "\n");
                }
                break;

                #endregion
            case FrameType.ACK:
                #region ACK
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram = Encoding.Default.GetBytes(input);              //потом это кыш

                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Telegram_s = Encoding.Default.GetString(Telegram);
                    //Log.AppendText("[" + DateTime.Now + "] Отправлено ACK согласие на принятие файла: " + Telegram_s + "\n");
                }
                break;

                #endregion
            case FrameType.FILEOK:
                if (IsConnected())
                {
                    ByteToEncode = File.ReadAllBytes(input);
                    FilePath     = input;
                    size         = new byte[sizeLenght];
                    size         = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString()); //нужны байты
                    //Telegram = Encoding.Default.GetBytes(size); //потом это кыш

                    BufferToSend = new byte[Header.Length + size.Length];     //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    size.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    size_s = Encoding.Default.GetString(size);
                    Log.AppendText("[" + DateTime.Now + "] Отправлена информация о размере файла: " + size_s + "\n");
                    //SuccessfulFrameNumber = int.Parse(Telegram_s);
                }
                break;

            case FrameType.FRAME:
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram     = Encoding.Default.GetBytes(input);          //потом это кыш
                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Telegram_s = Encoding.Default.GetString(Telegram);
                    //Log.AppendText("[" + DateTime.Now + "] получен Frame >  " + Telegram_s + " .Отправлено подтверждение о получении.\n");
                    //SuccessfulFrameNumber = int.Parse(Telegram_s);
                }
                else
                {
                    Log.Invoke(new EventHandler(delegate
                    {
                        Log.AppendText("[" + DateTime.Now + "] : Передача файла нарушена.\n" + "Последний успешный фрейм: " + SuccessfulFrameNumber.ToString());
                    }));
                    MessageBox.Show("Соединение прервано. Передача нарушена.");
                    BreakConnection = true;
                    break;
                }
                break;

            case FrameType.FILE:
                #region FILE
                int i;
                int parts = 0;
                int EncodedByteIndex;
                int Part_ByteEncodedIndex;
                ByteEncoded = new byte[0];
                size        = new byte[0];
                NumOfFrames = new byte[0];


                if (IsConnected())
                {
                    if (BreakConnection == false)
                    {
                        ByteToEncode = File.ReadAllBytes(@FilePath);

                        size = new byte[sizeLenght];
                        size = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString());     //нужны байты
                        //WriteData(Encoding.Default.GetString(size), FrameType.FILEOK);
                        NumOfFrames = new byte[NumOfFrameLenght];
                        FrameNumber = new byte[NumOfFrameLenght];

                        string typeFile = @input.Split('.')[1];
                        fileId[0] = TypeFile_to_IdFile(typeFile);


                        ByteEncoded = new byte[ByteToEncode.Length * 2];
                        for (i = 0; i < ByteToEncode.Length; i++)
                        {
                            Hamming.HammingEncode74(ByteToEncode[i]).CopyTo(ByteEncoded, i * 2);
                        }

                        if (ByteEncoded.Length + InfoLen < Port.WriteBufferSize)
                        {
                            BufferToSend = new byte[InfoLen + ByteEncoded.Length];
                            Header.CopyTo(BufferToSend, 0);
                            fileId.CopyTo(BufferToSend, Header.Length);
                            size.CopyTo(BufferToSend, Header.Length + fileId.Length);

                            NumOfFrames = Encoding.Default.GetBytes(1.ToString());
                            NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);

                            FrameNumber = Encoding.Default.GetBytes(1.ToString());
                            FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);


                            ByteEncoded.CopyTo(BufferToSend, InfoLen);
                            bool flag = false;
                            while (!flag)
                            {
                                if (MessageBox.Show("Отправить?", "Файл", MessageBoxButtons.YesNo) == DialogResult.Yes)
                                {
                                    flag = true;
                                    Port.Write(BufferToSend, 0, BufferToSend.Length);

                                    //loading.Hide();
                                    MessageBox.Show("Готово!");
                                    //loading.progressBar1.Value = 0;
                                    //loading.i = 1;
                                }
                                else
                                {
                                    flag = true;
                                    //loading.Hide();
                                    //loading.progressBar1.Value = 0;
                                    MessageBox.Show("Вы отменили передачу файла.");
                                    // loading.i = 1;
                                }
                            }
                        }
                        else
                        {
                            parts       = (int)Math.Ceiling((double)ByteEncoded.Length / (double)(Port.WriteBufferSize - InfoLen));
                            NumOfFrames = Encoding.Default.GetBytes(parts.ToString());
                        }
                        SuccessfulFrameNumber = 0;
                    }

                    for (i = SuccessfulFrameNumber; i < parts; i++)
                    {
                        BreakConnection = false;

                        EncodedByteIndex      = i * (Port.WriteBufferSize - InfoLen);
                        Part_ByteEncodedIndex = (Port.WriteBufferSize - InfoLen);

                        byte[] Part_ByteEncoded = new byte[Part_ByteEncodedIndex];

                        int Part_Len = 0;
                        if (((ByteEncoded.Length - EncodedByteIndex) >= Part_ByteEncodedIndex))
                        {
                            Part_Len = Part_ByteEncodedIndex;
                        }

                        else if (ByteEncoded.Length - EncodedByteIndex > 0)
                        {
                            Part_Len = ByteEncoded.Length - i * (Port.WriteBufferSize - InfoLen);
                        }

                        BufferToSend = new byte[Port.WriteBufferSize];

                        Header.CopyTo(BufferToSend, 0);
                        fileId.CopyTo(BufferToSend, Header.Length);
                        size.CopyTo(BufferToSend, Header.Length + fileId.Length);

                        NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);

                        FrameNumber = Encoding.Default.GetBytes((i + 1).ToString());
                        FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);

                        Array.ConstrainedCopy(ByteEncoded, EncodedByteIndex, BufferToSend, InfoLen, Part_Len);

                        //Log.AppendText("[" + DateTime.Now + "] : Отправляется фрейм: " + (SuccessfulFrameNumber + 1).ToString() + "\n");

                        Port.Write(BufferToSend, 0, BufferToSend.Length);
                        int ByteCheck;

                        if (i > 0)
                        {
                            int WaitTime = 0;
                            ByteCheck = Port.ReadByte();
                            while (ByteCheck != (int)STARTBYTE)
                            {
                                if (WaitTime <= 1000)
                                {
                                    Thread.Sleep(100);
                                    WaitTime += 100;
                                    ByteCheck = Port.ReadByte();
                                }
                            }
                            ByteCheck = Port.ReadByte();
                            if (ByteCheck == (int)FrameType.FRAME)
                            {
                                int    n             = FrameNumber.Length;//Port.BytesToRead;
                                byte[] msgByteBuffer = new byte[n];

                                Port.Read(msgByteBuffer, 0, n);     //считываем сообщение
                                string Message = Encoding.Default.GetString(msgByteBuffer);
                                Log.Invoke(new EventHandler(delegate
                                {
                                    Log.AppendText("[" + DateTime.Now + "] : Получено подтверждение об успешной доставке Frame " + Message + "\n");
                                }));
                                SuccessfulFrameNumber = int.Parse(Message);
                            }

                            if (i == SuccessfulFrameNumber)
                            {
                                continue;
                            }


                            if (i != SuccessfulFrameNumber)
                            {
                                MessageBox.Show("Передача файла прервана");
                                BreakConnection = true;
                            }
                        }
                        if (BreakConnection == true)
                        {
                            MessageBox.Show("Восстановите соединение или отмените отправку файла", "Файл", MessageBoxButtons.OKCancel);

                            while ((IsConnected()) || (MessageBox.Show("Отправить?", "Файл", MessageBoxButtons.OKCancel) == DialogResult.Cancel))
                            {
                                MessageBox.Show("Восстановите соединение или отмените отправку файла", "Файл", MessageBoxButtons.OKCancel);
                            }

                            if (MessageBox.Show("Отправить?", "Файл", MessageBoxButtons.OKCancel) == DialogResult.Cancel)
                            {
                                break;
                            }
                        }
                    }
                }
                else
                {
                    Log.Invoke(new EventHandler(delegate
                    {
                        Log.AppendText("[" + DateTime.Now + "] : Передача файла нарушена.\n" + "Последний успешный фрейм: " + SuccessfulFrameNumber.ToString());
                    }));
                    MessageBox.Show("Соединение прервано. Передача нарушена.");
                    BreakConnection = true;
                    break;
                }
                break;
                #endregion

            default:
                if (IsConnected())
                {
                    Port.Write(Header, 0, Header.Length);
                }
                break;
            }                                                                                                                                  //Зачем такая конструкция?
            Log.Invoke(new EventHandler(delegate
            {
                Log.AppendText("sent frame " + type + "\n"); //всё записываем, мы же снобы
            }));
        }
Example #3
0
        public void WriteData(string input, FrameType type)
        {
            byte[] Header = { STARTBYTE, (byte)type };

            byte[] fileId = { 0 };
            byte[] size;
            byte[] NumOfFrames;
            byte[] FrameNumber;

            byte[] BufferToSend;
            byte[] Telegram;
            string Telegram_s;
            string size_s;

            byte[] ByteToEncode;
            byte[] ByteEncoded;


            switch (type)
            {
            case FrameType.ERR_FILE:


                break;

            case FrameType.MSG:
                #region MSG
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram = Encoding.Default.GetBytes(input);              //потом это кыш

                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Log.AppendText("(" + Port.PortName + ") WriteData: sent message >  " + Encoding.Default.GetString(Telegram) + "\n");
                }
                break;
                #endregion

            case FrameType.ACK:
                #region ACK
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram = Encoding.Default.GetBytes(input);              //потом это кыш

                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Telegram_s = Encoding.Default.GetString(Telegram);
                }
                break;
                #endregion

            case FrameType.FILEOK:
                #region FILEOK
                if (IsConnected())
                {
                    ByteToEncode = File.ReadAllBytes(input);
                    FilePath     = input;
                    size         = new byte[sizeLenght];
                    size         = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString()); //нужны байты
                    //Telegram = Encoding.Default.GetBytes(size); //потом это кыш

                    BufferToSend = new byte[Header.Length + size.Length];     //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    size.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    size_s = Encoding.Default.GetString(size);
                    Log.AppendText("[" + DateTime.Now + "] Отправлена информация о размере файла: " + size_s + " байт\n");
                    //SuccessfulFrameNumber = int.Parse(Telegram_s);
                }
                break;
                #endregion

            case FrameType.FRAME:
                #region FRAME
                if (IsConnected())
                {
                    // Telegram[] = Coding(input);
                    Telegram     = Encoding.Default.GetBytes(input);          //потом это кыш
                    BufferToSend = new byte[Header.Length + Telegram.Length]; //буфер для отправки = заголовок+сообщение
                    Header.CopyTo(BufferToSend, 0);
                    Telegram.CopyTo(BufferToSend, Header.Length);

                    Port.Write(BufferToSend, 0, BufferToSend.Length);
                    Telegram_s = Encoding.Default.GetString(Telegram);

                    //SuccessfulFrameNumber = int.Parse(Telegram_s);
                }
                else
                {
                    Log.Invoke(new EventHandler(delegate
                    {
                        Log.AppendText("[" + DateTime.Now + "]: Передача файла нарушена.\n");
                    }));
                    ProgressBar.Invoke(new EventHandler(delegate
                    {
                        ProgressBar.Visible = false;
                    }));
                    BreakConnection = true;
                    break;
                }
                break;
                #endregion

            case FrameType.FILE:
                #region FILE
                int i;
                int parts = 0;
                int EncodedByteIndex;
                int Part_ByteEncodedIndex;
                ByteEncoded = new byte[0];
                size        = new byte[0];
                NumOfFrames = new byte[0];


                if (IsConnected())
                {
                    ByteToEncode = File.ReadAllBytes(@FilePath);
                    //b_ChooseFile.Invoke(new EventHandler(delegate
                    //{
                    //    b_ChooseFile.Enabled = false;
                    //}));
                    b_ChooseFile.Invoke(new EventHandler(delegate
                    {
                        b_ChooseFile.Enabled = false;
                    }));
                    b_OpenPort.Invoke(new EventHandler(delegate
                    {
                        b_OpenPort.Enabled = false;
                    }));
                    size = new byte[sizeLenght];
                    size = Encoding.Default.GetBytes(((double)ByteToEncode.Length).ToString());     //нужны байты
                    //WriteData(Encoding.Default.GetString(size), FrameType.FILEOK);
                    NumOfFrames = new byte[NumOfFrameLenght];
                    FrameNumber = new byte[NumOfFrameLenght];

                    string typeFile = @input.Split('.')[1];
                    fileId[0] = TypeFile_to_IdFile(typeFile);


                    ByteEncoded = new byte[ByteToEncode.Length * 2];
                    for (i = 0; i < ByteToEncode.Length; i++)
                    {
                        Hamming.HammingEncode74(ByteToEncode[i]).CopyTo(ByteEncoded, i * 2);
                    }

                    if (ByteEncoded.Length + InfoLen < Port.WriteBufferSize)
                    {
                        BufferToSend = new byte[InfoLen + ByteEncoded.Length];
                        Header.CopyTo(BufferToSend, 0);
                        fileId.CopyTo(BufferToSend, Header.Length);
                        size.CopyTo(BufferToSend, Header.Length + fileId.Length);

                        NumOfFrames = Encoding.Default.GetBytes(1.ToString());
                        NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);

                        FrameNumber = Encoding.Default.GetBytes(1.ToString());
                        FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);


                        ByteEncoded.CopyTo(BufferToSend, InfoLen);
                        bool flag = false;
                        while (!flag)
                        {
                            if (MessageBox.Show("Отправить?", "Файл", MessageBoxButtons.YesNo) == DialogResult.Yes)
                            {
                                flag = true;
                                Port.Write(BufferToSend, 0, BufferToSend.Length);

                                //loading.Hide();
                                MessageBox.Show("Готово!");
                                //loading.progressBar1.Value = 0;
                                //loading.i = 1;
                            }
                            else
                            {
                                flag = true;
                                //loading.Hide();
                                //loading.progressBar1.Value = 0;
                                MessageBox.Show("Вы отменили передачу файла.");
                                // loading.i = 1;
                            }
                        }
                    }
                    else
                    {
                        //EncodedByteIndex;
                        //Part_ByteEncodedIndex;

                        parts = (int)Math.Ceiling((double)ByteEncoded.Length / (double)(Port.WriteBufferSize - InfoLen));
                        ProgressBar.Invoke(new EventHandler(delegate
                        {
                            ProgressBar.Visible = true;
                            ProgressBar.Maximum = parts;
                        }));
                        NumOfFrames = Encoding.Default.GetBytes(parts.ToString());

                        for (i = 0; i < parts; i++)
                        {
                            EncodedByteIndex      = i * (Port.WriteBufferSize - InfoLen);
                            Part_ByteEncodedIndex = (Port.WriteBufferSize - InfoLen);

                            byte[] Part_ByteEncoded = new byte[Part_ByteEncodedIndex];

                            int Part_Len = 0;
                            if (((ByteEncoded.Length - EncodedByteIndex) >= Part_ByteEncodedIndex))
                            {
                                Part_Len = Part_ByteEncodedIndex;
                            }

                            else if (ByteEncoded.Length - EncodedByteIndex > 0)
                            {
                                Part_Len = ByteEncoded.Length - i * (Port.WriteBufferSize - InfoLen);
                            }


                            BufferToSend = new byte[Port.WriteBufferSize];

                            Header.CopyTo(BufferToSend, 0);
                            fileId.CopyTo(BufferToSend, Header.Length);
                            size.CopyTo(BufferToSend, Header.Length + fileId.Length);

                            NumOfFrames.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght);

                            FrameNumber = Encoding.Default.GetBytes((i + 1).ToString());
                            FrameNumber.CopyTo(BufferToSend, Header.Length + fileId.Length + sizeLenght + NumOfFrameLenght);

                            Array.ConstrainedCopy(ByteEncoded, EncodedByteIndex, BufferToSend, InfoLen, Part_Len);


                            if (IsConnected())
                            {
                                Port.Write(BufferToSend, 0, BufferToSend.Length);
                            }
                            Log.Invoke(new EventHandler(delegate
                            {
                                Log.AppendText("[" + DateTime.Now + "]: Отправка кадра " + (i + 1).ToString() + "\n");
                                Log.ScrollToCaret();
                            }));
                            if (ProgressBar.Value != parts)
                            {
                                ProgressBar.Invoke(new EventHandler(delegate
                                {
                                    ProgressBar.Value++;
                                }));
                            }

                            byte[] ByteCheck = new byte[1];

                            if (i > 0 && IsConnected())
                            {
                                //Thread.Sleep(10);
                                int WaitTime = 0;
                                try
                                {
                                    Port.Read(ByteCheck, 0, 1);
                                }
                                catch (Exception e)
                                {
                                    Log.AppendText(e.Message);
                                    break;
                                }

                                while (ByteCheck[0] != STARTBYTE)
                                {
                                    if (WaitTime <= 100)
                                    {
                                        Thread.Sleep(10);
                                        WaitTime += 10;
                                        Port.Read(ByteCheck, 0, 1);
                                    }
                                    else
                                    {
                                        MessageBox.Show("Передача файла прервана");
                                        break;
                                    }
                                }
                                if (IsConnected())
                                {
                                    continue;
                                }
                                Port.Read(ByteCheck, 0, 1);
                                if (ByteCheck[0] == (int)FrameType.FRAME)
                                {
                                    int    n             = FrameNumber.Length;//Port.BytesToRead;
                                    byte[] msgByteBuffer = new byte[n];

                                    Port.Read(msgByteBuffer, 0, n);     //считываем сообщение
                                    string Message = Encoding.Default.GetString(msgByteBuffer);

                                    SuccessfulFrameNumber = int.Parse(Message);
                                }

                                if (i == SuccessfulFrameNumber)
                                {
                                    continue;
                                }
                            }
                            if (!IsConnected())
                            {
                                Log.Invoke(new EventHandler(delegate
                                {
                                    Log.AppendText("[" + DateTime.Now + "]: Передача файла нарушена\n");
                                }));
                                DialogResult result;
                                while (!IsConnected())
                                {
                                    result = MessageBox.Show("Соединение прервано. Передача нарушена.\n"
                                                             + "Восстановите соединение и нажмите ОК для докачки файла.\n"
                                                             + "Иначе нажмите ОТМЕНА.",
                                                             "Ошибка",
                                                             MessageBoxButtons.OKCancel,
                                                             MessageBoxIcon.Error);
                                    if (result == DialogResult.Cancel)
                                    {
                                        Log.Invoke(new EventHandler(delegate
                                        {
                                            Log.AppendText("[" + DateTime.Now + "]: Передача файла отменена\n");
                                        }));
                                        ProgressBar.Invoke(new EventHandler(delegate
                                        {
                                            ProgressBar.Value = 0;
                                        }));
                                        b_ChooseFile.Invoke(new EventHandler(delegate
                                        {
                                            b_ChooseFile.Enabled = true;
                                        }));
                                        return;
                                    }
                                }
                                //BreakConnection = true;
                                i = SuccessfulFrameNumber - 1;
                                //break;
                            }
                        }
                        Log.Invoke(new EventHandler(delegate
                        {
                            Log.AppendText("[" + DateTime.Now + "]: Файл успешно передан\n");
                        }));
                        ProgressBar.Invoke(new EventHandler(delegate
                        {
                            ProgressBar.Value = 0;
                        }));
                        b_ChooseFile.Invoke(new EventHandler(delegate
                        {
                            b_ChooseFile.Enabled = true;
                        }));
                        b_OpenPort.Invoke(new EventHandler(delegate
                        {
                            b_OpenPort.Enabled = true;
                        }));
                    }
                }
                else
                {
                    Log.Invoke(new EventHandler(delegate
                    {
                        Log.AppendText("[" + DateTime.Now + "]: Передача файла нарушена.\n" + "Последний успешный фрейм: " + SuccessfulFrameNumber.ToString());
                    }));


                    BreakConnection = true;
                    break;
                }
                break;
                #endregion

            default:
                if (IsConnected())
                {
                    Port.Write(Header, 0, Header.Length);
                }
                break;
            }                                                                                                                                  //Зачем такая конструкция?
        }