RF_TRIO_PLL_ZIG/Basic_Terminal/Func/Update_Serial.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System.Windows.Forms;


namespace RF_TRIO_PLL_ZIG
{
    class Update_Serial
    {
        public byte[] Firmware_byte_load;
        byte Data_Request_Val = 0;
        int FirmTotalcnt = 0;
        int FirmCurrcnt = 0;
        int PreFirmSendingcnt = 0;
        int FirmSendingcnt = 0;
        int pretempupdateret = 0;
        bool update_ready = false;
        const byte blucell_stx = 0xbe;
        const byte blucell_etx = 0xeb;
        const byte Termianl_Controller_Update_Ack = 0x11;
        const byte Termianl_Controller_Update_Nak = 0x22;
        const byte Termianl_Controller_FirmwareUpdateLen = 250;
        const byte Termianl_Reset = 0x0A;
        const byte Termianl_BootStart = 0x0B;
        const int POLYNOMIAL = 0x131; // P(x) = x^8 + x^5 + x^4 + 1 = 100110001
        Bluecell_BootProtocol Bluecell_BootProtocol = new Bluecell_BootProtocol();
        Download_bar download_Bar = new Download_bar();
        private delegate void StringSend(string Text);
        private delegate void VoidSend();
        OpenFileDialog ofd;
        Serial serial;


        private byte Data_Request_Func
        {
            get
            { return Data_Request_Val; }
            set
            { Data_Request_Val = value; }

        }

        public bool Update_ready { get => update_ready; set => update_ready = value; }


        /***
*Data File open
***/
        public string ShowFileOpenDialog(ref Serial serial, object ofd)
        {
            byte[] tempdata = new byte[5];
            this.ofd = (OpenFileDialog)ofd;
            this.serial = (Serial)serial;
            //파일오픈창 생성 및 설정
            this.ofd.Title = "업데이터 파일 탐색기";
            this.ofd.FileName = "*.bin";
            this.ofd.Filter = "binary 파일 (*.binary,*.bin) | *.binary;, *.bin; | 모든 파일 (*.*) | *.*";

            //파일 오픈창 로드
            DialogResult dr = this.ofd.ShowDialog();

            //OK버튼 클릭시
            if (dr == DialogResult.OK)
            {
                //File명과 확장자를 가지고 온다.
                string fileName = this.ofd.SafeFileName;
                //File경로와 File명을 모두 가지고 온다.
                string fileFullName = this.ofd.FileName;
                //File경로만 가지고 온다.
                string filePath = fileFullName.Replace(fileName, "");
                this.serial.debug_hextoasciiConvert();

                //출력 예제용 로직
                //  label1.Text = "File Name  : " + fileName;
                // label2.Text = "Full Name  : " + fileFullName;
                // label3.Text = "File Path  : " + filePath;`
                //File경로 + 파일명 리턴
                this.serial.FileDownloadClass_Get(this);
                Data_Request_Func = 1;

                Firmware_byte_load = File.ReadAllBytes(this.ofd.FileName);
                FirmTotalcnt = Firmware_byte_load.Length / Termianl_Controller_FirmwareUpdateLen;

                FirmCurrcnt = 0;
                PreFirmSendingcnt = 0;
                FirmSendingcnt = 0;
                Update_ready = true;
                tempdata[0] = 0xbe;
                tempdata[1] = Termianl_Reset;
                tempdata[2] = 0x02;
                tempdata[3] = STH30_CreateCrc(tempdata, tempdata[2]);
                tempdata[4] = 0xeb;
               
                this.serial.Serial_DataSend(tempdata, 5);
                try
                {
                   // Controller_Debug.Controller_TX_TextLoad(tempdata);
                }
                catch { }
                download_Bar.ShowDialog();
                /*Update_label.Visible = true;
                progressBar1.Visible = true;*/
                return fileFullName;
            }
            //취소버튼 클릭시 또는 ESC키로 파일창을 종료 했을경우
            else if (dr == DialogResult.Cancel)
            {
                return "";
            }

            return "";
        }

        public void FirmwareUpdateCheck(byte check)
        {

            byte[] temp_data = new byte[Termianl_Controller_FirmwareUpdateLen + 5];
            byte cnt = 3;
            int lastlen = 0;
            // FirmTotalcnt = Firmware_byte_load.Length / Termianl_Controller_FirmwareUpdateLen;
            lastlen = Firmware_byte_load.Length % Termianl_Controller_FirmwareUpdateLen;
            temp_data[0] = blucell_stx;
            temp_data[1] = 0xDD;
            if (check == Termianl_BootStart)
            {
                System.Threading.Thread.Sleep(2000);
            }
            if (Termianl_Controller_Update_Ack == check || Termianl_BootStart == check)
            {
                PreFirmSendingcnt = FirmSendingcnt;
                if (FirmCurrcnt != FirmTotalcnt)
                {
                    temp_data[2] = Termianl_Controller_FirmwareUpdateLen + 2;
                    for (int i = 0; i < Termianl_Controller_FirmwareUpdateLen; i++)
                    {
                        temp_data[cnt++] = Firmware_byte_load[FirmSendingcnt++];
                    }
                    FirmCurrcnt++;
                    temp_data[Termianl_Controller_FirmwareUpdateLen + 3] = STH30_CreateCrc(temp_data, temp_data[2]);
                    temp_data[Termianl_Controller_FirmwareUpdateLen + 4] = blucell_etx;
                }
                else
                {
                    Update_ready = false;
                    temp_data[1] = 0xEE;
                    temp_data[2] = Convert.ToByte(lastlen + 2);
                    for (int i = 0; i < lastlen; i++)
                    {
                        temp_data[cnt++] = Firmware_byte_load[FirmSendingcnt++];
                    }
                    temp_data[temp_data[2] + 1] = STH30_CreateCrc(temp_data, temp_data[2]);
                    temp_data[temp_data[2] + 2] = blucell_etx;
                    /*ownload_Bar.ShowDialog();*/
                    this.download_Bar.Invoke(new StringSend(this.download_Bar.Progressbar), "0 %");
                    //download_Bar.Progressbar("0 %");
                    this.download_Bar.Progressbar_gauge_zero();
                    this.download_Bar.FormClosed(this.download_Bar);
                    this.serial.debug_asciitohexConvert();
                    FirmSendingcnt = PreFirmSendingcnt = FirmCurrcnt = FirmTotalcnt = pretempupdateret = Data_Request_Val = 0;
      
                    /*Update_label.Text = "0%";
                    Update_label.Visible = false;
                    progressBar1.Visible = false;
                    progressBar1.Value = 0;*/
                    //  MessageBox.Show("Update Complete !!");
                }

            }
            else
            {
                FirmSendingcnt = PreFirmSendingcnt;
                if (FirmCurrcnt != FirmTotalcnt)
                {
                    temp_data[2] = Termianl_Controller_FirmwareUpdateLen + 2;
                    for (int i = 0; i < Termianl_Controller_FirmwareUpdateLen; i++)
                    {
                        temp_data[cnt++] = Firmware_byte_load[FirmSendingcnt++];

                    }
                    FirmCurrcnt++;
                    temp_data[Termianl_Controller_FirmwareUpdateLen + 3] = STH30_CreateCrc(temp_data, temp_data[2]);
                    temp_data[Termianl_Controller_FirmwareUpdateLen + 4] = blucell_etx;
                }
                else
                {
                    Update_ready = false;
                    temp_data[1] = 0xEE;
                    temp_data[2] = Convert.ToByte(lastlen + 2);
                    for (int i = 0; i < lastlen; i++)
                    {
                        temp_data[cnt++] = Firmware_byte_load[FirmSendingcnt++];
                    }
                    temp_data[temp_data[2] + 1] = STH30_CreateCrc(temp_data, temp_data[2]);
                    temp_data[temp_data[2] + 2] = blucell_etx;
                    /* Update_label.Visible = false;
                     progressBar1.Visible = false;*/
                    download_Bar.Close();
                }
            }
            int tempupdateret = Firmware_byte_load.Length / 100;
            tempupdateret = FirmSendingcnt / tempupdateret;
            //CheckForIllegalCrossThreadCalls = false;
            this.download_Bar.Update_Percent(Convert.ToString(tempupdateret));
            if (pretempupdateret != tempupdateret)
            {

                for (int i = 0; i <= tempupdateret - this.download_Bar.Update_get(); i++)
                {
                    this.download_Bar.PerformStepup(this.download_Bar);
                    //this.download_Bar.PerformStepinc(tempupdateret);
                    // progressBar1.PerformStep();
                }

                pretempupdateret = tempupdateret;
            }

            //serialPort1.Write(temp_data, 0, temp_data[2] + 3);
            this.serial.Serial_DataSend(temp_data, temp_data[2] + 3);
            try
            {
               // Controller_Debug.Controller_TX_TextLoad(temp_data);
            }
            catch { }
        }

        public void Termianl__Operate(byte[] Text)
        {
            byte Type = 0;
            Type = Text[Bluecell_BootProtocol.bluecell_type];
            switch (Type)
            {
               
                case Termianl_BootStart:
                case Termianl_Controller_Update_Ack:
                case Termianl_Controller_Update_Nak:
                    if (Update_ready == true)
                        FirmwareUpdateCheck(Type);
                    break;
               
                default:
                    // MessageBox.Show("다시 시도 해주세요.");
                    break;
            }
        }

        byte STH30_CreateCrc(byte[] data, byte nbrOfBytes)
        {
            byte bit;        // bit mask
            int crc = 0xFF; // calculated checksum
            byte byteCtr;    // byte counter
            byte index = 1;
            // calculates 8-Bit checksum with given polynomial
            for (byteCtr = 0; byteCtr < nbrOfBytes; byteCtr++)
            {
                crc ^= (data[index++]);
                for (bit = 8; bit > 0; --bit)
                {
                    if (Convert.ToBoolean(crc & 0x80)) { crc = (crc << 1) ^ POLYNOMIAL; }
                    else crc = (crc << 1);
                }
            }
            return (byte)crc;
        }
        
    }
}