Jdas_Mbic/Jdas_Mbic/Terminal.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

//Add code
using System.IO;
using System.IO.Ports;
using Jdas_Mbic.Function;

namespace Jdas_Mbic
{
    public partial class Terminal : Form
    {
        public Terminal()
        {
            InitializeComponent();
        }

        private void Terminal_FormClosing(object sender, FormClosingEventArgs e)
        {
            this.Dispose();
        }

        
        JdasMbic main_form;
        int LineLimit = 500;
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);
        private const int WM_SETREDRAW = 11;
        
        public RadioButton RadioButton_ascii { get => radioButton_ascii; set => radioButton_ascii = value; }
        public RadioButton RadioButton_hex { get => radioButton_hex; set => radioButton_hex = value; }
#if true
        public void Data_Recv_Str(string text)
        {

            int nLimitLines = Convert.ToInt32(LineLimit); //제한 라인 수
            try
            {
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, false, 0);
                }
                catch (Exception e) { MessageBox.Show(e.StackTrace); }
                if (tbReceived.Lines.Length > nLimitLines)
                {
                    LinkedList<string> tempLines = new LinkedList<string>(tbReceived.Lines);
                    while ((tempLines.Count - nLimitLines) > 0)
                    {
                        tempLines.RemoveFirst();
                    }

                    tbReceived.Lines = tempLines.ToArray();

                }
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, true, 0);
                }
                catch { return; }
                tbReceived.AppendText(text);
                tbReceived.SelectionStart = tbReceived.Text.Length;//맨 마지막 선택... 
                tbReceived.ScrollToCaret();
            }
            catch { try { SendMessage(this.Handle, WM_SETREDRAW, true, 0); } catch { return; } }
        }
#endif
#if false
        public void Data_Recv_Hex(byte[] text)
        {
           int nLimitLines = Convert.ToInt32(LineLimit); //제한 라인 수
            try
            {
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, false, 0);
                }
                catch (Exception e) { MessageBox.Show(e.StackTrace); }
                if (tbReceived.Lines.Length > nLimitLines)
                {
                    LinkedList<string> tempLines = new LinkedList<string>(tbReceived.Lines);
                    while ((tempLines.Count - nLimitLines) > 0)
                    {
                        tempLines.RemoveFirst();
                    }

                    tbReceived.Lines = tempLines.ToArray();

                }
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, true, 0);
                }
                catch { return; }
                tbReceived.AppendText(text.ToString());
                tbReceived.SelectionStart = tbReceived.Text.Length;//맨 마지막 선택... 
                tbReceived.ScrollToCaret();
            }
            catch { try { SendMessage(this.Handle, WM_SETREDRAW, true, 0); } catch { return; } }

        }
#endif
        public void Data_Recv_Hex(byte[] text)
        {
            string AppendMessage = "";

            int nLimitLines = Convert.ToInt32(LineLimit); //제한 라인 수
            try
            {/*
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, false, 0);
                }
                catch (Exception e) { MessageBox.Show(e.StackTrace); }*/
                for (int i = 0; i < text.Length; i++)
                {
                    AppendMessage += Convert.ToString(text[i], 16);
                    AppendMessage += " ";
                }
                AppendMessage += "\r\n";
                tbReceived.AppendText(AppendMessage);

                if (tbReceived.Lines.Length > nLimitLines)
                {
                    LinkedList<string> tempLines = new LinkedList<string>(tbReceived.Lines);

                    while ((tempLines.Count - nLimitLines) > 0)
                    {
                        tempLines.RemoveFirst();
                    }

                    tbReceived.Lines = tempLines.ToArray();
                }
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, true, 0);
                }
                catch { return; }
                tbReceived.Select(tbReceived.Text.Length, 0);
                tbReceived.ScrollToCaret();
            }
            catch { try { SendMessage(this.Handle, WM_SETREDRAW, true, 0); } catch { return; } }

        }
        public void Data_Send(byte[] text)
        {
            string AppendMessage = "\n[TX]";

            int nLimitLines = Convert.ToInt32(LineLimit); //제한 라인 수
            try
            {
                for (int i = 0; i < text.Length; i++)
                {
                    AppendMessage += Convert.ToString(text[i], 16);
                }
                tbReceived.AppendText(AppendMessage);
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, false, 0);
                }
                catch { return; }
                if (tbReceived.Lines.Length > nLimitLines)
                {
                    LinkedList<string> tempLines = new LinkedList<string>(tbReceived.Lines);

                    while ((tempLines.Count - nLimitLines) > 0)
                    {
                        tempLines.RemoveFirst();
                    }

                    tbReceived.Lines = tempLines.ToArray();
                }
                try
                {
                    SendMessage(this.Handle, WM_SETREDRAW, true, 0);
                }
                catch { return; }
                tbReceived.Select(tbReceived.Text.Length, 0);
                tbReceived.ScrollToCaret();
            }
            finally { }

        }


        private void Button_Send_Click(object sender, EventArgs e)
        {

        }

        private void Button_Clear_Click(object sender, EventArgs e)
        {

        }
        public void hex_to_ascii_radiobuttonConvert()
        {
            radioButton_hex.Checked = true;
            radioButton_ascii.Checked = false;
        }
        public void ascii_to_hex_radiobuttonConvert()
        {
            radioButton_ascii.Checked = true;
            radioButton_hex.Checked = false;
        }
        public void Debug_Main_Form_Get(object frm)
        {
            this.main_form = (JdasMbic)frm;
        }







        //public string Serial_Name { get => serialPort.PortName;  set => serialPort.PortName = value;}
        Data_Handler data_Handler = new Data_Handler();
        //FileDownload fileDownload;
        Update_Serial fileDownload = null;
        public void SetPortNameValues(object obj)
        {
            string[] ports = SerialPort.GetPortNames(); // load all name of com ports to string
            try
            {
                ((ComboBox)obj).Items.Clear(); //delete previous names in combobox items
            }
            catch { }
           ((ComboBox)obj).DataSource = null;
            foreach (string port in ports) //add this names to comboboxPort items
            {
                ((ComboBox)obj).Items.Add(port); //if there are some com ports ,select first
            }
            if (((ComboBox)obj).Items.Count > 0)
            {
                ((ComboBox)obj).SelectedIndex = 0;
            }
            else
            {
                ((ComboBox)obj).Text = " "; //if there are no com ports ,write Empty
            }
        }
        public void Serial_Initialize(ref ComboBox cb_port)
        {
            
            this.serialPort = new System.IO.Ports.SerialPort();
            this.serialPort.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(this.Serial_DataRecvFunction);

            cb_port.BeginUpdate();
            foreach (string comport in SerialPort.GetPortNames())//foreach (string comport in SerialPort_TestProgram.GetPortNames())
            {
                cb_port.Items.Add(comport);
            }
            cb_port.EndUpdate();
            //SerialPort 초기 설정.
         //  serialPort.Encoding = Encoding.GetEncoding("Windows-1252");
            cb_port.DataSource =  SerialPort.GetPortNames();
            try
            {
                serialPort_JdasMbic.PortName =  cb_port.SelectedItem.ToString();
                serialPort_JdasMbic.BaudRate = (int)921600;
                serialPort_JdasMbic.DataBits = (int)8;
                serialPort_JdasMbic.Parity = System.IO.Ports.Parity.None;
                serialPort_JdasMbic.StopBits = StopBits.One;
            }
            catch { }

        }
        private delegate void StringSend(string Text);
        private delegate void ByteSend(byte[] Text);

        public string Str2hex(string strData,Boolean Compotable)
        {
            string resultHex = string.Empty;
            byte[] arr_byteStr = Encoding.Default.GetBytes(strData);

            foreach (byte byteStr in arr_byteStr)
            {
                if(Compotable == true)
                    resultHex += string.Format("{0:X2}", byteStr) + " ";
                else
                    resultHex += string.Format("{0:X2}", byteStr);
            }

            return resultHex;
        }

        static public byte[] Str2bytes(string byteData)
        {

#if false
            System.Text.ASCIIEncoding asencoding = new System.Text.ASCIIEncoding();
            return Encoding.Default.GetBytes(byteData);
#else 
            byte[] arr_byteStr = Encoding.Default.GetBytes(byteData);
            return arr_byteStr;
#endif
        }
        private delegate void BoolSet();
        public void Serial_DataRecvFunction(object sender, SerialDataReceivedEventArgs e)
        {
            string tmpSTR = "";
            Data_Handler data_Handler = new Data_Handler();
            int nLnegth = serialPort.BytesToRead;
            byte[] btdata = new byte[nLnegth];

            serialPort.Read(btdata, 0, nLnegth);

            main_form.Invoke(new BoolSet(main_form.RX_Light_ON));
            main_form.TX_RX_Light = true;
            if (this.Debug.Created && Debug.RadioButton_ascii.Checked == true)
            {
                string data = Encoding.Default.GetString(btdata);
                // string data = serialPort.ReadExisting();

                if (Debug.RadioButton_ascii.Checked == true)
                    Debug.Invoke(new StringSend(Debug.Data_Recv_Str), data);
                else
                    Debug.Invoke(new StringSend(Debug.Data_Recv_Str), Str2hex(data, true));
               
                data_Handler.Recv_dataCheck(this,this.main_form,this.fileDownload, btdata);
            }
            else
            {
                // 리스트 두개 사용
                if (nLnegth > 0)
                {
                    if (this.Debug.Created)
                    {
                        if (this.Debug.radioButton_ascii.Checked == true)
                        {
                            tmpSTR = Encoding.Default.GetString(btdata).TrimEnd('\0');
                            Debug.Invoke(new StringSend(Debug.Data_Recv_Str), Str2hex(tmpSTR, true));
                        }
                        else
                        {
                            Debug.Invoke(new ByteSend(Debug.Data_Recv_Hex), btdata);
                        }
                    }
                    else
                    {
                        if (this.Debug.Created)
                            Debug.Invoke(new ByteSend(Debug.Data_Recv_Hex), btdata);
                    }
                    // 이부분에서 데이타 처리하는 부분으로 전송하여 사용하면 됨
                }

                data_Handler.Recv_dataCheck(this, this.main_form,this.fileDownload, btdata);
            }
            /****
             *메모리 누수 방지용 코드
             */
            System.GC.Collect(0, GCCollectionMode.Forced);
            System.GC.WaitForFullGCComplete();
        }
        public Boolean Serial_PortOpen(ref Button Btn_Portonoff,ref ComboBox cb)
        {
            Boolean ret = false;
            try
            {
                if (serialPort.IsOpen) { //When the port is open
                    serialPort.Close();
                    Btn_Portonoff.Text = "Port Open";
                    ret = true;
                }
                else//When the port is close
                {
                    if (cb.Text != "")
                    {
                        serialPort.Open();
                        Btn_Portonoff.Text = "Port Close";
                        Debug.Debug_Main_Form_Get(this.main_form);
                    }
                    else
                    {
                        MessageBox.Show("Port is not set");
                        ret = true;
                    }
                }
            }
            catch
            {
                MessageBox.Show("already port open " + Serial_Name);
               
            }
            return ret;
        }
        public void Serial_TerminalOpen(object serial)
        {
            this.Debug.Serial_ClassSet(serial);
            try
            {
                this.Debug.Show();
            }
            catch
            {
                Debug = new Debug();
                this.Debug.Show();
            }
        }
        public void Serial_DataSend(byte[] data)
        {
            try
            {
                serialPort.Write(data,0,data.Length);
                main_form.pictureBox_R_TX.Visible = false;
                main_form.pictureBox_G_TX.Visible = true;
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        public void Serial_DataSend(byte[] buffer, int count)
        {
            try {
                serialPort.Write(buffer, 0, count);
                main_form.Invoke(new BoolSet(main_form.TX_Light_ON));
                main_form.TX_RX_Light = true;
            }
            catch
            {
                System.Diagnostics.Process.GetCurrentProcess().Kill();
                MessageBox.Show("Port Open Failed!!!");
            }
        }
       
        public void FileDownloadClass_Set(object filedownload)
        {
            this.fileDownload = (Update_Serial)filedownload;
        }
        public object FileDownloadClass_Get()
        {
            return this.fileDownload;
        }
        public void Test_Serial()
        {
            byte[] tempdata = new byte[1024];
            for (int i = 0; i < 255; i++)
            {

                tempdata[i] = Convert.ToByte(i);
                
                
            }
            this.serialPort.Write(tempdata, 0, 255);
            //this.serialPort.Write(tempdata.ToString());

        }
        public void debug_hextoasciiConvert()
        {
            if(this.Debug.Created)
                this.Debug.hex_to_ascii_radiobuttonConvert();
        }
        public void debug_asciitohexConvert()
        {
            if (this.Debug.Created)
                this.Debug.ascii_to_hex_radiobuttonConvert();
        }
        
        public void Serial_Main_Form_Get(object frm)
        {
            this.main_form = (Main_Form)frm;
        }

    }
}