SerialMonitor2/Form_Main.cs - main - AwsomeMeNGL/SerialMonitor_582-1_Practicing

SerialMonitor2/Form_Main.cs
788 строк30 KB
MrDeef
Исправил исключение при выходе
03 мар 2025, 17:58
03 мар 2025, 17:58a9ba08d
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Xml;
using System.Text;
using System.Windows.Forms;
using SerialPortNamespace;
using SettingsManagement;
using System.Linq;
using Utilities;
using System.Security.Cryptography.X509Certificates;

namespace SerialMonitor2
{
    public partial class Form_Main : Form
    {
// Constants
#region
        private const string strFORM_MAIN_STATUS_READY = "Готов";
        private const string TITLE_TEXT = "Serial Monitor 2 v.1.0";
        private const string strFORM_MAIN_PORT_PROPERTIES_PREFIX = "Порт";
        private const string SETTINGS_FILE_NAME = "SerialMonitor2.cfg";

        public string[] DATA_TYPE = {
            CONST_SETTINGS.DATA_TYPE_ASCII,
            CONST_SETTINGS.DATA_TYPE_HEX
        };
#endregion

        private CSerialPortGUI moduleSerialPort;
        private CSettings moduleSettings;
        private Timer timerStatusMonitor;
        private string Status = strFORM_MAIN_STATUS_READY;
        private List<string> _encodings= new List<string>();
        private int _RXD_Type_index ;
        private int _TXD_Type_index ;
        public static Form_Main Instance { get; private set; }
// Constructor
        public Form_Main()
        {
            InitializeComponent();

            Instance = this;

            this.toolStripStatusLabel_PortStatus.Text = "";

            // Place serial port controls
            this.moduleSerialPort = new CSerialPortGUI(CSerialPortGUI.eMainBoxSize.FULL);
            this.moduleSerialPort.groupBox_SerialPort_Main.Location = new Point(12, 12);
            this.moduleSerialPort.richTextBox_Log.Location = new Point(6 + this.moduleSerialPort.groupBox_SerialPort_Main.Width + 8, 6);
            this.Controls.Add(moduleSerialPort.groupBox_SerialPort_Main);
            this.moduleSerialPort.richTextBox_Log = this.richTextBox_RXD;

            this.comboBox_TXD_PacketType.Items.AddRange(DATA_TYPE);
            this.comboBox_TXD_DataType.Items.AddRange(DATA_TYPE);
            this.comboBox_RXD_DataType.Items.AddRange(DATA_TYPE);
            toolStripStatusLabel_TXD.Text += " 0";
            toolStripStatusLabel_RXD.Text += " 0";
            moduleSerialPort.RXD_Count_up += RXD_count_change;
            // Init settings management
            SettingsInit();

            this.timerStatusMonitor = new Timer()
            {
                Interval = 500,
                Enabled = false
            };
            this.timerStatusMonitor.Tick += TimerStatusMonitor_Tick;
        }

        private void Form_Main_Load(object sender, EventArgs e)
        {
            PocketsLoad();
            // Load settings
            moduleSettings.Load();
            

            this.timerStatusMonitor.Start();
             _RXD_Type_index = comboBox_RXD_DataType.SelectedIndex;
             _TXD_Type_index = comboBox_TXD_DataType.SelectedIndex;
    }

        private void SettingsInit()
        {
            this.moduleSettings = new CSettings();

            this.moduleSettings.AddMethods(moduleSerialPort.SettingsLoad, moduleSerialPort.SettingsToXML, XML_TAG.STRUCT_PORT_SETTINGS_NAME);
            this.moduleSettings.AddMethods(this.SettingsLoad, this.SettingsToXML, XML_TAG.STRUCT_FORMPARAM_NAME);
        }
        private void Form_Main_FormClosing(object sender, FormClosingEventArgs e)
        {
            moduleSettings.Store();
            if (checkBox_Settings_LogSave.Checked)
            {
                LogSave();
            }
            
        }

        string[] DefaultSettings = {
            "100",                      // Location X
            "100",                      // Location Y
            CONST_SETTINGS.CHECKED,     // Saving log
            "SerialMonitorLog" + CONST_LOG.FILE_EXTENTION,  // Log file name
            "",                         // Last TXD Packet
            CONST_SETTINGS.DATA_TYPE_ASCII, // TXD Packet Type
            "0",                        // TXD Packet Delay
            "0",                        // TXD Packet Repeat
            CONST_SETTINGS.DATA_TYPE_ASCII, // TXD Data Type
            CONST_SETTINGS.DATA_TYPE_ASCII, // RXD Data Type
        };
        void SettingsLoad(XmlNode node)
        {
            XmlDocument xmlDoc = new XmlDocument();
            XmlNode settingRoot = xmlDoc.ImportNode(node, true);
            XmlNode attr;

            // Validate Settings
            attr = settingRoot.Attributes.GetNamedItem(XML_TAG.NAME);
            if (attr == null) return;
            if (!String.Equals(attr.Value, XML_TAG.STRUCT_FORMPARAM_NAME)) return;

            string[] strSettings = DefaultSettings;
            // Extract settings from XML
            foreach (XmlNode childNode in settingRoot.ChildNodes)
            {
                if (String.Equals(childNode.Name, XML_TAG.PARAM_LOCATION_X)) strSettings[0] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_LOCATION_Y)) strSettings[1] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_SAVE_LOG)) strSettings[2] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_LAST_PACK)) strSettings[3] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_TXD_PACK_TYPE)) strSettings[4] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_TXD_PACK_DELAY)) strSettings[5] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_TXD_PACK_REPEAT)) strSettings[6] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_TXD_DATA_TYPE)) strSettings[7] = childNode.InnerText;
                if (String.Equals(childNode.Name, XML_TAG.PARAM_RXD_DATA_TYPE)) strSettings[8] = childNode.InnerText;
            }

            // Apply configs
            try 
            {
                SettingsApply(strSettings);
            }
            catch 
            {
                SettingsApply(DefaultSettings);
            }
        }
        void SettingsApply(string[] settings)
        {
            int strIdx = 0;
            int x, y;
            x = Convert.ToInt32(settings[strIdx++]);
            y = Convert.ToInt32(settings[strIdx++]);
            this.Location = new Point(x, y);

            if (CONST_SETTINGS.CHECKED == settings[strIdx++])
                this.checkBox_Settings_LogSave.Checked = true;
            else
                this.checkBox_Settings_LogSave.Checked = false;
            if (settings[strIdx] != "null")
            {
                try
                {
                    comboBox_TXD_Packet.SelectedIndex = int.Parse(settings[strIdx]);
                }
                catch (Exception e) 
                {
                    comboBox_TXD_Packet.SelectedIndex = -1;
                }

            }
            strIdx++;
            this.comboBox_TXD_PacketType.SelectedItem = settings[strIdx++];
            this.numericUpDown_TXD_Delay.Value = Convert.ToDecimal(settings[strIdx++]);
            this.numericUpDown_TXD_Repeat.Value = Convert.ToDecimal(settings[strIdx++]);
            this.comboBox_TXD_DataType.SelectedItem = settings[strIdx++];
            this.comboBox_RXD_DataType.SelectedItem = settings[strIdx++];
        }

        XmlNode SettingsToXML()
        {
            XmlDocument xmlDoc = new XmlDocument();
            XmlNode setting;
            XmlElement param;
            XmlAttribute attr;
            XmlText text;

            // Setting structure name
            setting = xmlDoc.CreateElement(XML_TAG.SETTING);
            attr = xmlDoc.CreateAttribute(XML_TAG.NAME);
            text = xmlDoc.CreateTextNode(XML_TAG.STRUCT_FORMPARAM_NAME);
            attr.AppendChild(text);
            setting.Attributes.Append(attr);

            Point location = this.GetLocation();
            // Param LocationX
            param = xmlDoc.CreateElement(XML_TAG.PARAM_LOCATION_X);
            text = xmlDoc.CreateTextNode(location.X.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param LocationY
            param = xmlDoc.CreateElement(XML_TAG.PARAM_LOCATION_Y);
            text = xmlDoc.CreateTextNode(location.Y.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);

            // Param Saving Log
            param = xmlDoc.CreateElement(XML_TAG.PARAM_SAVE_LOG);
            if (this.checkBox_Settings_LogSave.Checked)
                text = xmlDoc.CreateTextNode(CONST_SETTINGS.CHECKED);
            else
                text = xmlDoc.CreateTextNode(CONST_SETTINGS.UNCHECKED);
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param Last TXD Packet
            param = xmlDoc.CreateElement(XML_TAG.PARAM_LAST_PACK);
            if (comboBox_TXD_Packet.SelectedIndex != -1 && comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex] != null)
            {
                text = xmlDoc.CreateTextNode(comboBox_TXD_Packet.SelectedIndex.ToString());
            }
            else
            {
                text = xmlDoc.CreateTextNode("null");
            }
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param TXD Packet Type
            param = xmlDoc.CreateElement(XML_TAG.PARAM_TXD_PACK_TYPE);
            text = xmlDoc.CreateTextNode(this.comboBox_TXD_PacketType.SelectedItem?.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param TXD Packet Delay
            param = xmlDoc.CreateElement(XML_TAG.PARAM_TXD_PACK_DELAY);
            text = xmlDoc.CreateTextNode(this.numericUpDown_TXD_Delay.Value.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param TXD Packet Repeat
            param = xmlDoc.CreateElement(XML_TAG.PARAM_TXD_PACK_REPEAT);
            text = xmlDoc.CreateTextNode(this.numericUpDown_TXD_Repeat.Value.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);
            // Param TXD Data Type
            param = xmlDoc.CreateElement(XML_TAG.PARAM_TXD_DATA_TYPE);
            text = xmlDoc.CreateTextNode(this.comboBox_TXD_DataType.SelectedItem?.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);
            
            // Param RXD Data Type
            param = xmlDoc.CreateElement(XML_TAG.PARAM_RXD_DATA_TYPE);
            text = xmlDoc.CreateTextNode(this.comboBox_RXD_DataType.SelectedItem?.ToString());
            param.AppendChild(text);
            setting.AppendChild(param);

            // Pockets Save
            param = xmlDoc.CreateElement(XML_TAG.POCKETS);
            for(int i=0;i< comboBox_TXD_Packet.Items.Count;i++)
            {
                XmlElement pocket = xmlDoc.CreateElement(XML_TAG.POCKET);
                text = xmlDoc.CreateTextNode(comboBox_TXD_Packet.Items[i].ToString());
                attr = xmlDoc.CreateAttribute(XML_TAG.ENCODING);
                XmlText attr_text = xmlDoc.CreateTextNode(_encodings[i]);
                attr.AppendChild(attr_text);
                pocket.Attributes.Append(attr);
                pocket.AppendChild(text);
                param.AppendChild(pocket);

            }
            setting.AppendChild(param);

            return setting;
        }

        Point GetLocation()
        {
            int x, y;
            Size screenSize = Screen.PrimaryScreen.Bounds.Size;
            Point formLocation = this.Location;

            x = formLocation.X;
            y = formLocation.Y;

            if ((x < 0) || (x > screenSize.Width) &&
                (y < 0) || (y > screenSize.Height))
            {
                x = screenSize.Width / 2 - this.MinimumSize.Width / 2;
                y = screenSize.Height / 2 - this.MinimumSize.Height / 2;
                formLocation = new Point(x, y);
            }

            return formLocation;
        }

        private void TimerStatusMonitor_Tick(object sender, EventArgs e)
        {
            this.toolStripStatusLabel_PortStatus.Text = this.moduleSerialPort.GetPortStatus();
        }

        public string RXD_PacketType
        {
            get
            {
                return comboBox_RXD_DataType.SelectedItem.ToString();
            }
        }

        private void buttonSendData_Click(object sender, EventArgs e)
        {
            try
            {
                string dataToSend = comboBox_TXD_Packet.SelectedItem?.ToString();

                if (string.IsNullOrEmpty(dataToSend))
                {
                    MessageBox.Show("Выберите пакет для отправки!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }

                byte[] buffer;

                // Проверка типа данных
                if (comboBox_TXD_PacketType.SelectedItem.ToString() == "ASCII")
                {
                    buffer = Encoding.ASCII.GetBytes(dataToSend);
                }
                else if (comboBox_TXD_PacketType.SelectedItem.ToString() == "HEX")
                {
                    buffer = dataToSend.Split(' ') 
                                      .Select(b => Convert.ToByte(b, 16))
                                      .ToArray();
                }
                else
                {
                    MessageBox.Show("Неизвестный тип данных!");
                    return;
                }

                //Курсор в конец
                richTextBox_TXD.SelectionStart = richTextBox_TXD.Text.Length;

                //Очистка написанного (если есть)
                DeleteCurrentLine();

                if ((int)numericUpDown_TXD_Repeat.Value > 1)
                {
                    int repeatCount = (int)numericUpDown_TXD_Repeat.Value;
                    int delay = (int)numericUpDown_TXD_Delay.Value;


                    SendPackets(buffer, repeatCount, delay);
                }
                else
                    SendOnePacket(buffer);

            }
            catch (Exception ex)
            {
                MessageBox.Show("Ошибка отправки данных: " + ex.Message);
            }
        }

        private void SendOnePacket(byte[] buffer)
        {
            // Sending Packet
            moduleSerialPort.SendNormal(buffer);

            // Log packet in richTextBox_TXD
            string formattedPacket = Functions.FormatPacket(buffer, comboBox_TXD_DataType.SelectedItem.ToString());
            richTextBox_TXD.AppendText($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} Отправлено / {formattedPacket}{Environment.NewLine}");
            TXD_count_change();

        }

        private void SendPackets(byte[] buffer, int repeatCount, int delay)
        {
            int currentRepeat = 0;


            Timer sendTimer = new Timer
            {
                Interval = delay,
                Enabled = true
            };


            sendTimer.Tick += (s, e) =>
            {
                if (currentRepeat >= repeatCount)
                {

                    sendTimer.Stop();
                    sendTimer.Dispose();
                    return;
                }

                // Log packet in richTextBox_TXD
                string formattedPacket = Functions.FormatPacket(buffer, comboBox_TXD_DataType.SelectedItem.ToString());
                richTextBox_TXD.AppendText($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} " +
                    $"Отправлено ({currentRepeat + 1}/{repeatCount}) / {formattedPacket}{Environment.NewLine}");

                moduleSerialPort.SendNormal(buffer);
                TXD_count_change();

                currentRepeat++;
            };

            sendTimer.Start();
        }

        private void richTextBox_ManualSending(object sender, KeyEventArgs e)
        {
            string textToSend = richTextBox_TXD.Lines.LastOrDefault()?.Trim();

            if (!string.IsNullOrEmpty(textToSend))
            {
                byte[] buffer;
                if (comboBox_TXD_PacketType.SelectedItem.ToString() == CONST_SETTINGS.DATA_TYPE_ASCII)
                {
                    buffer = Encoding.ASCII.GetBytes(textToSend);
                }
                else if (comboBox_TXD_PacketType.SelectedItem.ToString() == CONST_SETTINGS.DATA_TYPE_HEX)
                {
                    try
                    {
                        buffer = textToSend
                            .Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                            .Select(hex => Convert.ToByte(hex, 16))
                            .ToArray();
                    }
                    catch
                    {
                        MessageBox.Show("Некорректный HEX-формат!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        return;
                    }
                }
                else
                {
                    MessageBox.Show("Неизвестный формат данных!", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                //Очистка написанного
                DeleteCurrentLine();

                SendOnePacket(buffer);
                TXD_count_change();

                richTextBox_TXD.SelectionStart = richTextBox_TXD.Text.Length;
                richTextBox_TXD.ScrollToCaret();
            }
        }

        private void SendOneCharToPort(char keyChar)
        {
            byte[] buffer = Encoding.ASCII.GetBytes(new char[] { keyChar });
            moduleSerialPort.SendNormal(buffer);
            TXD_count_change();
        }

        private void LogLoad()
        {

        }
        private void LogSave()
        {
            XmlDocument xmlDoc = new XmlDocument();
            XmlNode log;
            XmlElement root;
            XmlElement param;
            XmlAttribute attr;
            string[] TXD_LOG = richTextBox_TXD.Text.Split('\n');
            XmlText text;
            string[] RXD_LOG = richTextBox_RXD.Text.Split('\n');


            xmlDoc.RemoveAll();
            root = xmlDoc.CreateElement(XML_TAG.ROOT_LOG);
            xmlDoc.AppendChild(root);
            // Create title
            XmlElement title = xmlDoc.CreateElement(XML_TAG.TITLE);
            text = xmlDoc.CreateTextNode(TITLE_TEXT);
            title.AppendChild(text);
            root.AppendChild(title);
            // log structure name
            log = xmlDoc.CreateElement(XML_TAG.LOG);
            attr = xmlDoc.CreateAttribute(XML_TAG.NAME);
            text = xmlDoc.CreateTextNode(XML_TAG.STRUCT_LOG_NAME);
            attr.AppendChild(text);
            log.Attributes.Append(attr);

            //Param TXD History
            param = xmlDoc.CreateElement(XML_TAG.PARAM_TXD_HISTORY);
            text=xmlDoc.CreateTextNode("\n");
            param.AppendChild(text);
            foreach (string node in TXD_LOG)
            {
                text = xmlDoc.CreateTextNode("  "+node + "\n");
                param.AppendChild(text);
            }
            log.AppendChild(param);

            param = xmlDoc.CreateElement(XML_TAG.PARAM_RXD_HISTORY);
            text = xmlDoc.CreateTextNode("\n");
            param.AppendChild(text);
            foreach (string node in RXD_LOG)
            {
                text = xmlDoc.CreateTextNode("  " + node + "\n");
                param.AppendChild(text);
            }
            log.AppendChild(param);

            string currentDir = Application.ExecutablePath;
            root.AppendChild(log);
            currentDir = currentDir.Substring(0, currentDir.LastIndexOf("\\") + 1);
            string save = "SerialMonitor2Log " + DateTime.Now.ToString();
            save = save.Replace(".", ".");
            save = save.Replace(":", ";");
            currentDir += "Logs\\";
            save +=".log";
            try
            {
                xmlDoc.Save(currentDir + save);
            }
            catch (Exception e)
            {

            }


        }

        private void richTextBox_TXD_KeyDown(object sender, KeyEventArgs e)
        {
            //Курсор в конец
            richTextBox_TXD.SelectionStart = richTextBox_TXD.Text.Length;

            //Предотвращение стирания строки
            if (e.KeyCode == Keys.Back)
            {
                int cursorPosition = richTextBox_TXD.SelectionStart; 
                int lineIndex = richTextBox_TXD.GetLineFromCharIndex(cursorPosition); 
                int lineStart = richTextBox_TXD.GetFirstCharIndexFromLine(lineIndex); 

                // Если курсор в начале строки, отменяем удаление
                if (cursorPosition == lineStart)
                {
                    e.SuppressKeyPress = true;
                }
            }

            if (e.KeyCode == Keys.Enter)
            {
                if (!checkBox_StreamSwitch.Checked)
                    richTextBox_ManualSending(sender, e);

                e.SuppressKeyPress = true;
                return;
            }

            if (checkBox_StreamSwitch.Checked)
            {
                char keyChar = Functions.KeyEventArgsToChar(e);
                if (keyChar != '\0') // Проверяем, что символ корректный
                {
                    SendOneCharToPort(keyChar);
                }
            }
        }



        private void checkBox_StreamSwitch_CheckedChanged(object sender, EventArgs e)
        {
            DeleteCurrentLine();
        }


        private void DeleteCurrentLine()
        {
            if (richTextBox_TXD.Lines.Length == 0) return; // Проверяем, есть ли строки

            int cursorPosition = richTextBox_TXD.SelectionStart;

            // Определение индекса начала и конца строки
            int lineIndex = richTextBox_TXD.GetLineFromCharIndex(cursorPosition);

            if (lineIndex < 0 || lineIndex >= richTextBox_TXD.Lines.Length) return; // Защита от выхода за границы

            int startIndex = richTextBox_TXD.GetFirstCharIndexFromLine(lineIndex);
            int endIndex = startIndex + richTextBox_TXD.Lines[lineIndex].Length;

            richTextBox_TXD.Select(startIndex, endIndex - startIndex);
            richTextBox_TXD.SelectedText = "";
        }



         /// <summary>
        /// Загрузка пакетов данных из конфига
        /// </summary>
        private void PocketsLoad()
        {
            XmlDocument xmlDoc_Settings = new XmlDocument();
            XmlElement root;
            XmlNode attr;
            string currentDir = Application.ExecutablePath;
            currentDir = currentDir.Substring(0, currentDir.LastIndexOf("\\") + 1);
            try
            {
                xmlDoc_Settings.Load(currentDir + SETTINGS_FILE_NAME);
            }
            catch (Exception e)
            {
                return;
            }
            root = xmlDoc_Settings.DocumentElement;
            foreach (XmlNode node in root)
            {
                if (node.Name == XML_TAG.SETTING)
                {
                    foreach (XmlNode node2 in node)
                    {
                        if (node2.Name == XML_TAG.POCKETS)
                        {
                            foreach (XmlNode node3 in node2)
                            {
                                comboBox_TXD_Packet.Items.Add(node3.InnerText);
                                string attribute = node3.Attributes.GetNamedItem(XML_TAG.ENCODING).Value;
                                if (attribute != null)
                                {
                                    _encodings.Add(attribute);
                                }

                            }
                        }

                    }

                }

            }
        }

        private void comboBox_TXD_Packet_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex] != null)
            {
                if (_encodings[comboBox_TXD_Packet.SelectedIndex] == "ASCII")
                {
                    comboBox_TXD_PacketType.SelectedIndex = 0;
                }
                if (_encodings[comboBox_TXD_Packet.SelectedIndex] == "HEX")
                {
                    comboBox_TXD_PacketType.SelectedIndex = 1;
                }
            }
        }

        private void comboBox_TXD_PacketType_SelectedIndexChanged(object sender, EventArgs e)
        {
            
           
        }

        private void comboBox_TXD_PacketType_SelectionChangeCommitted(object sender, EventArgs e)
        {
            if (comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex] != null && _encodings[comboBox_TXD_Packet.SelectedIndex]!= comboBox_TXD_PacketType.Text)
            {

                if (comboBox_TXD_PacketType.SelectedIndex == 0)
                {
                    _encodings[comboBox_TXD_Packet.SelectedIndex] = "ASCII";
                    comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex] = Functions.ASCII_Converter(comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex].ToString());
                }
                if (comboBox_TXD_PacketType.SelectedIndex == 1)
                {
                    _encodings[comboBox_TXD_Packet.SelectedIndex] = "HEX";
                    comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex] = Functions.HEX_Converter(comboBox_TXD_Packet.Items[comboBox_TXD_Packet.SelectedIndex].ToString(),' ');
                }
            }
        }

        private void comboBox_TXD_DataType_SelectionChangeCommitted(object sender, EventArgs e)
        {
           

        }

        private void comboBox_TXD_DataType_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (comboBox_TXD_DataType.SelectedIndex != _TXD_Type_index)
            {
                string[] main_array;
                string out_array = "";
                string[] currentt_array;
                main_array = richTextBox_TXD.Text.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string line in main_array)
                {
                    currentt_array = line.Split(new[] { " / " }, StringSplitOptions.None);
                    if (comboBox_TXD_DataType.SelectedIndex == 0)
                    {
                        currentt_array[1] = Functions.ASCII_Converter(currentt_array[1]);
                        currentt_array[0] += " / ";
                        out_array += String.Concat(currentt_array);
                        out_array += '\n';
                    }

                    if (comboBox_TXD_DataType.SelectedIndex == 1)
                    {
                        currentt_array[1] = Functions.HEX_Converter(currentt_array[1], ' ');
                        currentt_array[0] += " / ";
                        out_array += String.Concat(currentt_array);
                        out_array += '\n';
                    }

                    richTextBox_TXD.Text = out_array;
                    _TXD_Type_index = comboBox_TXD_DataType.SelectedIndex;
                }
            }
           
        }

        private void TXD_count_change()
        {
                string[] splitStr = toolStripStatusLabel_TXD.Text.Split(' ');
                splitStr[0] += " ";
                splitStr[1] = (int.Parse(splitStr[1]) + 1).ToString();
                toolStripStatusLabel_TXD.Text = String.Concat(splitStr);
        }

        private void RXD_count_change()
        {
            
                string[] splitStr = toolStripStatusLabel_RXD.Text.Split(' ');
                splitStr[0] += " ";
                splitStr[1] = (int.Parse(splitStr[1]) + 1).ToString();
                toolStripStatusLabel_RXD.Text = String.Concat(" " + splitStr);
            
        }

        private void comboBox_RXD_DataType_SelectedIndexChanged(object sender, EventArgs e)
        {
            if(comboBox_RXD_DataType.SelectedIndex != _RXD_Type_index)
            {
                string[] main_array;
                string out_array = "";
                string[] currentt_array;
                main_array = richTextBox_RXD.Text.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string line in main_array)
                {
                    currentt_array = line.Split(new[] { " / " }, StringSplitOptions.None);
                    if (currentt_array[1] != "")
                    {
                        if (comboBox_RXD_DataType.SelectedIndex == 0)
                        {
                            currentt_array[1] = Functions.ASCII_Converter(currentt_array[1]);
                            currentt_array[0] += " / ";
                            out_array += String.Concat(currentt_array);
                            out_array += '\n';
                        }

                        if (comboBox_RXD_DataType.SelectedIndex == 1)
                        {
                            currentt_array[1] = Functions.HEX_Converter(currentt_array[1], ' ');
                            currentt_array[0] += " / ";
                            out_array += String.Concat(currentt_array);
                            out_array += '\n';
                        }


                    }
                    else
                    {
                        currentt_array[0] += " / ";
                        out_array += String.Concat(currentt_array);
                        out_array += '\n';
                    }

                }
                richTextBox_RXD.Text = out_array;
                _RXD_Type_index= comboBox_RXD_DataType.SelectedIndex;
            }
            
        }

    }
}