Esempio n. 1
0
 private void btn_BL_connet_Click(object sender, EventArgs e)
 {
     Bl_Handler = BL_Handler.Enumerate(0x15A2, new[] { 0x0073 }).FirstOrDefault();
     if (Bl_Handler != null)
     {
         Bl_Handler.LogUpdate    += UpdateLogFromHandler;
         Bl_Handler.DataRecieved += PushReceiveData;
         Bl_Handler.Inserted     += DeviceInserted;
         Bl_Handler.Removed      += DeviceRemoved;
         Bl_Handler.StartListen();
     }
 }
Esempio n. 2
0
        private void btn_onekeyupdate_Click(object sender, EventArgs e)
        {
            btn_onekeyupdate.Enabled = false;
            bool BL_connect = false;

            Viewer.UpdateProgressBarCallback UpdateProgressBar = Assign_ProgressBar;
            Viewer.UpadateLogInvoke          UpdateLog         = LogUpdate;

            if (Viewer.fingerPrint == null)
            {
                Viewer.fingerPrint = new FingerPrint_API.FingerPrint();
                Viewer.fingerPrint.AutoConnect_Interval = 5000;
            }
            if (!Viewer.fingerPrint.IsConnected)
            {
                InitialDvice(true);
            }
            bool force_try = false;

            if (!Viewer._Initial)
            {
                DialogResult dr = MessageBox.Show("Can't Find Appropriate Device, Try Recovery?", "Connect Failed", MessageBoxButtons.YesNo);

                force_try = (dr == DialogResult.Yes) ? true : false;
            }

            if (Viewer._Initial || force_try)
            {
                int BLtry_count = 0;
                Invoke(UpdateLog, new Object[] { "Initializing FW Update Menager...", true });
                Invoke(UpdateLog, new Object[] { "Please Waiting...", false });
                while (Bl_Handler == null && BLtry_count < 5)
                {
                    Invoke(UpdateLog, new Object[] { "...", false });
                    System.Threading.Thread.Sleep(1000);
                    Bl_Handler = BL_Handler.Enumerate(0x15A2, new[] { 0x0073 }).FirstOrDefault();
                    BLtry_count++;
                }
                Invoke(UpdateLog, new Object[] { " ", true });
                if (Bl_Handler != null)
                {
                    Bl_Handler.LogUpdate    += UpdateLogFromHandler;
                    Bl_Handler.DataRecieved += ReceiveDataFlag;
                    Bl_Handler.StartListen();
                    BL_connect = true;
                    Invoke(UpdateLog, new Object[] { "Initializing FW Update Menager Success...", true });
                }
                else
                {
                    Invoke(UpdateLog, new Object[] { "Initializing Failed, Recovery Function Start...", true });

                    Sdp_Handler = SDP_Handler.Enumerate(0x1FC9, new[] { 0x0130 }).FirstOrDefault();
                    if (Sdp_Handler != null)
                    {
                        Sdp_Handler.DataRecieved += ReceiveDataFlag;
                        Sdp_Handler.StartListen();

                        Setup_BootLoader();
                    }
                    else
                    {
                        Invoke(UpdateLog, new Object[] { "Recovery Failed, Terminated...", true });
                    }
                }

                System.Threading.Thread.Sleep(3000);
                // Reconnect
                if (!BL_connect)
                {
                    Bl_Handler = BL_Handler.Enumerate(0x15A2, new[] { 0x0073 }).FirstOrDefault();
                    if (Bl_Handler != null)
                    {
                        Bl_Handler.LogUpdate    += UpdateLogFromHandler;
                        Bl_Handler.DataRecieved += ReceiveDataFlag;
                        Bl_Handler.StartListen();
                        BL_connect = true;
                        Invoke(UpdateLog, new Object[] { "Initializing FW Update Menager Success...", true });
                    }
                    else
                    {
                        Invoke(UpdateLog, new Object[] { "Initializing FW Upgrade Menager Fail... Terminated", true });
                    }
                }

                if (BL_connect)
                {
                    string ImageFilePath = tb_allinone_path.Text;
                    //Check Recipe//
                    if (!File.Exists("Auto_Recipe.txt"))
                    {
                        Invoke(UpdateLog, new Object[] { "Recipe Loss, Please Contact For Support", true });
                    }
                    else
                    {
                        Check_Recipe();
                        byte[] Image_data = Load_Image(ImageFilePath);
                        if (File_Support)
                        {
                            Do_Command(Image_data);
                        }
                        Invoke(UpdateLog, new Object[] { "Process Done", true });
                    }
                }
                if (File_Support)
                {
                    Viewer._Initial = false;
                    int try_count = 0;
                    Viewer.fingerPrint.Dispose();
                    Viewer.fingerPrint = new FingerPrint_API.FingerPrint();
                    rt_log.Text       += "Verificating...\n";
                    while (!Viewer._Initial && try_count < 3)
                    {
                        try_count++;
                        System.Threading.Thread.Sleep(3000);
                        InitialDvice(false);
                    }
                    if (!Viewer._Initial)
                    {
                        Invoke(UpdateLog, new Object[] { "Updated Failed Please Check Your Image File And Restart Upgrade Program", true });
                    }
                }
            }
            btn_onekeyupdate.Enabled = true;
        }
Esempio n. 3
0
        public void Do_Command(byte[] Image_data)
        {
            Viewer.UpadateLogInvoke UpdateLog = LogUpdate;
            byte[] image_Len = new byte[4] {
                0x00, 0x00, 0x00, 0x00
            };
            image_Len = BitConverter.GetBytes(Image_data.Length);
            Array.Reverse(image_Len);
            byte[] Erase_Len = new byte[4];
            Array.Copy(image_Len, Erase_Len, image_Len.Length);
            Erase_Len[3] = 0x00;
            Erase_Len[2] = BitConverter.GetBytes((((Erase_Len[2] / 16) + 2) * 16))[0];

            /////Load in Progress Done/////
            Invoke(UpdateLog, new Object[] { "Load in Image Progress Done", true });
            Invoke(UpdateLog, new Object[] { "Processing..., Please Waiting...", false });
            foreach (Command active_command in CommandList)
            {
                //Invoke(UpdateLog, new Object[] { "...", false });

                switch (BitConverter.ToString(active_command.command_type, 0))
                {
                case "02":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, Erase_Len, false);
                    wait_response_lock = true;
                    break;

                case "03":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                case "04":
                    int    file_pointer = 0;
                    byte[] HID_packet   = new byte[1016];
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, image_Len, true);
                    wait_response_lock = true;
                    while (file_pointer < Image_data.Length)
                    {
                        int data_len = ((Image_data.Length - file_pointer) > HID_packet.Length) ? HID_packet.Length : (Image_data.Length - file_pointer);
                        Array.Copy(Image_data, file_pointer, HID_packet, 0, data_len);
                        Bl_Handler.WriteData(HID_packet);
                        file_pointer += data_len;
                    }
                    wait_response_lock = true;
                    break;

                case "05":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2.Length, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                case "07":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                case "0B":

                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                case "0F":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                case "11":
                    Bl_Handler.WriteCommand(active_command.command_type, active_command.Para_1, active_command.Para_2, false);
                    wait_response_lock = true;
                    break;

                default:
                    break;
                }
            }
            Invoke(UpdateLog, new Object[] { " ", true });
        }
Esempio n. 4
0
        private void btn_send_BL_Click(object sender, EventArgs e)
        {
            Viewer.UpadateDataMapInvoke      UpdateDataMap     = Data_Process;
            Viewer.UpadateLogInvoke          UpdateLog         = LogUpdate;
            Viewer.UpdateProgressBarCallback UpdateProgressBar = Assign_ProgressBar;
            Invoke(UpdateProgressBar, 0);
            int para_1 = Int32.Parse(tb_BL_para1.Text, System.Globalization.NumberStyles.HexNumber);

            int para_2 = Convert.ToInt32(tb_BL_para2.Text);

            byte[] data = new byte[para_2];
            int    row = 0, col = 0, pcount = 0;

            if (cb_BL_command_type.Text == "FillMemory")
            {
                while (pcount < para_2 && dgv_datamap.Rows[row].Cells[col].Value != null)
                {
                    data[pcount] = byte.Parse(dgv_datamap.Rows[row].Cells[col].Value.ToString(), System.Globalization.NumberStyles.HexNumber);
                    pcount++;
                    col = (col + 1 > dgv_datamap.ColumnCount - 1) ? 0 : ++col;
                    if (col == 0)
                    {
                        row = (row + 1 > dgv_datamap.RowCount) ? row : ++row;
                    }
                }
            }

            Invoke(UpdateDataMap, new string[] { null });
            int command_type = 0;

            switch (cb_BL_command_type.Text)
            {
            case "FlashEraseRegion":
                command_type = 2;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            case "ReadMemory":
                command_type = 3;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            case "WriteMemory":
                Invoke(UpdateProgressBar, 20);
                command_type = 4;
                int      file_pointer = 0;
                string   file_path    = tb_BL_filepath.Text;
                char[]   spliter      = new char[] { '.' };
                string[] subcommand   = file_path.Split(spliter);
                string   file_posfix  = subcommand[subcommand.Length - 1];
                if (file_posfix == "s19")
                {
                    SREC_file srec       = new SREC_file(file_path);
                    byte[]    HID_packet = new byte[1016];

                    int datapacket_count_perstep = (srec.ivt_boot_image.Data.Length / HID_packet.Length) / 80;

                    Bl_Handler.WriteCommand(command_type, para_1, Convert.ToInt32(srec.ivt_boot_image.Data.Length), true);

                    int count = 0;
                    while (file_pointer < srec.ivt_boot_image.Data.Length)
                    {
                        int data_len = ((srec.ivt_boot_image.Data.Length - file_pointer) > HID_packet.Length) ? HID_packet.Length : (srec.ivt_boot_image.Data.Length - file_pointer);
                        Array.Copy(srec.ivt_boot_image.Data, file_pointer, HID_packet, 0, data_len);
                        Debug.WriteLine("pointer : " + file_pointer + ", data len : " + data_len);
                        Bl_Handler.WriteData(HID_packet);
                        file_pointer += data_len;
                        count++;
                        if (count == datapacket_count_perstep)
                        {
                            count = 0;
                            Invoke(UpdateProgressBar, 1);
                        }
                    }
                }
                else if (file_posfix == "bin")
                {
                    int        count       = 0;
                    long       preposition = 0;
                    byte[]     Filedata    = new byte[1016];
                    FileStream fileStream  = new FileStream(tb_BL_filepath.Text, FileMode.Open, FileAccess.Read);
                    Debug.WriteLine(fileStream.Length);
                    Bl_Handler.WriteCommand(command_type, para_1, Convert.ToInt32(fileStream.Length), true);
                    while (fileStream.Read(Filedata, 0, Filedata.Length) > 0)
                    {
                        Debug.WriteLine(fileStream.Position);
                        if (fileStream.Position == fileStream.Length)
                        {
                            byte[] partdata = new byte[fileStream.Position - preposition];
                            Array.Copy(Filedata, partdata, partdata.Length);
                            Bl_Handler.WriteData(partdata);
                            count += partdata.Length;
                        }
                        else
                        {
                            Bl_Handler.WriteData(Filedata);
                            count += Filedata.Length;
                        }
                        Debug.WriteLine("Write Count : " + count);
                        preposition = fileStream.Position;
                    }
                }
                break;

            case "FillMemory":
                command_type = 5;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, data, false);
                break;

            case "GetProperty":
                command_type = 7;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            case "Reset":
                command_type = 11;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            case "FlashReadOnce":
                command_type = 15;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            case "ConfigureQuadSPI":
                command_type = 17;
                Bl_Handler.WriteCommand(command_type, para_1, para_2, false);
                break;

            default:
                break;
            }

            Invoke(UpdateLog, "Command Process Done", true);
            Invoke(UpdateProgressBar, 100);
        }