public static bool Issue_BL_Reset()
{
bool result = false;
byte[] array = new byte[65];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 255;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag)
{
result = true;
}
return(result);
}
public static bool Retrieve_BL_FW_Version_Cmd(ref ushort p_bl_ver)
{
bool flag = false;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 0x76;
Utilities.m_flags.g_need_to_copy_bl_data = true;
if ((USBWrite.Send_Data_Packet_To_PICkitS(ref array) && Utilities.m_flags.g_bl_data_arrived_event.WaitOne(0x3e8, false)) && (Utilities.m_flags.bl_buffer[1] == 0x76))
{
p_bl_ver = (ushort)((Utilities.m_flags.bl_buffer[7] << 8) + Utilities.m_flags.bl_buffer[8]);
flag = true;
}
return(flag);
}
private static bool Send_MT2_RD_Command(byte p_sensor_id, bool p_trip, bool p_gdbnd, bool p_raw, bool p_avg, bool p_detect, bool p_aux1, bool p_aux2, bool p_status)
{
byte[] array = new byte[65];
byte b = 0;
if (p_trip)
{
b |= 1;
}
if (p_gdbnd)
{
b |= 2;
}
if (p_raw)
{
b |= 4;
}
if (p_avg)
{
b |= 8;
}
if (p_detect)
{
b |= 16;
}
if (p_aux1)
{
b |= 32;
}
if (p_aux2)
{
b |= 64;
}
if (p_status)
{
b |= 128;
}
array[0] = 0;
array[1] = 20;
array[2] = p_sensor_id;
array[3] = b;
array[4] = 0;
bool result = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
mTouch2.m_we_are_broadcasting = false;
return(result);
}
private static bool Send_MT2_RD_Command(byte p_sensor_id, bool p_trip, bool p_gdbnd, bool p_raw, bool p_avg, bool p_detect, bool p_aux1, bool p_aux2, bool p_status)
{
byte[] buffer = new byte[0x41];
byte num = 0;
if (p_trip)
{
num = (byte)(num | 1);
}
if (p_gdbnd)
{
num = (byte)(num | 2);
}
if (p_raw)
{
num = (byte)(num | 4);
}
if (p_avg)
{
num = (byte)(num | 8);
}
if (p_detect)
{
num = (byte)(num | 0x10);
}
if (p_aux1)
{
num = (byte)(num | 0x20);
}
if (p_aux2)
{
num = (byte)(num | 0x40);
}
if (p_status)
{
num = (byte)(num | 0x80);
}
buffer[0] = 0;
buffer[1] = 20;
buffer[2] = p_sensor_id;
buffer[3] = num;
buffer[4] = 0;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref buffer);
m_we_are_broadcasting = false;
return(flag);
}
internal static bool Send_MT2_RD_STATUS_Command()
{
byte[] array = new byte[65];
bool result = false;
array[0] = 0;
array[1] = 17;
array[2] = 0;
mTouch2.m_status_data_is_ready.Reset();
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag)
{
result = mTouch2.m_status_data_is_ready.WaitOne(500, false);
}
return(result);
}
public static bool Write_Gdbnd_Value(byte p_sensor_id, ushort p_gdbnd)
{
mTouch2.Send_MT2_RESET_Command();
byte[] array = new byte[65];
ushort time_interval = 0;
if (mTouch2.m_we_are_broadcasting && mTouch2.Send_MT2_RD_STATUS_Command())
{
time_interval = mTouch2.m_data_status.time_interval;
}
array[0] = 0;
array[1] = 35;
array[2] = p_sensor_id;
array[3] = 2;
array[4] = (byte)p_gdbnd;
array[5] = (byte)(p_gdbnd >> 8);
array[6] = 0;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag)
{
mTouch2.m_gdb_data_is_ready.Reset();
if (mTouch2.Send_MT2_RD_Command(p_sensor_id, false, true, false, false, false, false, false, false))
{
flag = mTouch2.m_gdb_data_is_ready.WaitOne(500, false);
if (flag)
{
mTouch2.m_sensor_data_mutex.WaitOne();
if (p_gdbnd != mTouch2.m_gdb_values[0])
{
flag = false;
}
mTouch2.m_sensor_data_mutex.ReleaseMutex();
}
}
}
if (mTouch2.m_we_are_broadcasting && mTouch2.Send_MT2_RD_STATUS_Command())
{
mTouch2.m_data_status.time_interval = time_interval;
mTouch2.Send_MT2_RD_AUTO_Command(mTouch2.m_data_status.broadcast_group_id, mTouch2.m_data_status.broadcast_enable_flags.trip, mTouch2.m_data_status.broadcast_enable_flags.guardband, mTouch2.m_data_status.broadcast_enable_flags.raw, mTouch2.m_data_status.broadcast_enable_flags.avg, mTouch2.m_data_status.broadcast_enable_flags.detect_flags, mTouch2.m_data_status.broadcast_enable_flags.aux1, mTouch2.m_data_status.broadcast_enable_flags.aux2, mTouch2.m_data_status.broadcast_enable_flags.status, mTouch2.m_data_status.time_interval);
}
return(flag);
}
public static bool write_and_verify_LIN_config_block(ref byte[] p_control_block_data, ref string p_result_str, bool p_perform_warm_and_cold_reset, ref string p_cb_data_str)
{
bool result = false;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref p_control_block_data);
Device.Clear_Status_Errors();
if (flag)
{
if (USBWrite.Update_Status_Packet())
{
Utilities.m_flags.g_status_packet_mutex.WaitOne();
int i;
for (i = 7; i < 31; i++)
{
if (Constants.STATUS_PACKET_DATA[i] != p_control_block_data[i - 5])
{
p_result_str = string.Format("Byte {0} failed verification in config block write.\n Value reads {1:X2}, but should be {2:X2}.", i - 7, Constants.STATUS_PACKET_DATA[i], p_control_block_data[i - 5]);
break;
}
}
if (i == 31)
{
result = true;
p_result_str = string.Format("PICkit Serial Analyzer correctly updated.", new object[0]);
p_cb_data_str = "";
for (i = 7; i < 31; i++)
{
p_cb_data_str += string.Format("{0:X2} ", Constants.STATUS_PACKET_DATA[i]);
}
}
Utilities.m_flags.g_status_packet_mutex.ReleaseMutex();
}
else
{
p_result_str = string.Format("Error requesting config verification - Config Block may not be updated correctly", new object[0]);
}
}
else
{
p_result_str = string.Format("Error sending config packet - Config Block may not be updated correctly", new object[0]);
}
return(result);
}
public static bool Clear_64_Bytes_of_Flash(ushort p_addr)
{
bool flag = false;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 3;
array[2] = 1;
array[3] = (byte)p_addr;
array[4] = (byte)(p_addr >> 8);
array[5] = 0;
Utilities.m_flags.g_need_to_copy_bl_data = true;
if (((USBWrite.Send_Data_Packet_To_PICkitS(ref array) && Utilities.m_flags.g_bl_data_arrived_event.WaitOne(0x3e8, false)) && ((Utilities.m_flags.bl_buffer[1] == 3) && (Utilities.m_flags.bl_buffer[2] == 1))) && (Utilities.m_flags.bl_buffer[3] == ((byte)p_addr)))
{
flag = true;
}
return(flag);
}
public static bool Write_Trip_Value(byte p_sensor_id, ushort p_trip)
{
Send_MT2_RESET_Command();
byte[] buffer = new byte[0x41];
ushort num = 0;
if (m_we_are_broadcasting && Send_MT2_RD_STATUS_Command())
{
num = m_data_status.time_interval;
}
buffer[0] = 0;
buffer[1] = 0x22;
buffer[2] = p_sensor_id;
buffer[3] = 2;
buffer[4] = (byte)p_trip;
buffer[5] = (byte)(p_trip >> 8);
buffer[6] = 0;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref buffer);
if (flag)
{
m_trip_data_is_ready.Reset();
if (Send_MT2_RD_Command(p_sensor_id, true, false, false, false, false, false, false, false))
{
flag = m_trip_data_is_ready.WaitOne(500, false);
if (flag)
{
m_sensor_data_mutex.WaitOne();
if (p_trip != m_trp_values[0])
{
flag = false;
}
m_sensor_data_mutex.ReleaseMutex();
}
}
}
if (m_we_are_broadcasting && Send_MT2_RD_STATUS_Command())
{
m_data_status.time_interval = num;
Send_MT2_RD_AUTO_Command(m_data_status.broadcast_group_id, m_data_status.broadcast_enable_flags.trip, m_data_status.broadcast_enable_flags.guardband, m_data_status.broadcast_enable_flags.raw, m_data_status.broadcast_enable_flags.avg, m_data_status.broadcast_enable_flags.detect_flags, m_data_status.broadcast_enable_flags.aux1, m_data_status.broadcast_enable_flags.aux2, m_data_status.broadcast_enable_flags.status, m_data_status.time_interval);
}
return(flag);
}
public static bool Send_CtrlBlkWrite_Cmd(ref byte[] p_data_array)
{
byte[] array = new byte[65];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 2;
int i;
for (i = 0; i < 24; i++)
{
array[i + 2] = p_data_array[i];
}
array[i] = 0;
USBWrite.Send_Cold_Reset_Cmd();
bool result = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
USBWrite.Send_Warm_Reset_Cmd();
USBWrite.Update_Status_Packet();
return(result);
}
public static bool Retrieve_BL_FW_Version_Cmd(ref ushort p_bl_ver)
{
bool result = false;
byte[] array = new byte[65];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 118;
Utilities.m_flags.g_need_to_copy_bl_data = true;
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag)
{
bool flag2 = Utilities.m_flags.g_bl_data_arrived_event.WaitOne(1000, false);
if (flag2 && Utilities.m_flags.bl_buffer[1] == 118)
{
p_bl_ver = (ushort)(((int)Utilities.m_flags.bl_buffer[7] << 8) + (int)Utilities.m_flags.bl_buffer[8]);
result = true;
}
}
return(result);
}
public static bool Clear_64_Bytes_of_Flash_return_fail_info(ushort p_addr, ref byte[] p_data, ref bool p_write_result, ref bool p_wait_result)
{
bool result = false;
bool flag = false;
byte[] array = new byte[65];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 3;
array[2] = 1;
array[3] = (byte)p_addr;
array[4] = (byte)(p_addr >> 8);
array[5] = 0;
Utilities.m_flags.g_need_to_copy_bl_data = true;
bool flag2 = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag2)
{
flag = Utilities.m_flags.g_bl_data_arrived_event.WaitOne(1000, false);
if (flag)
{
if (Utilities.m_flags.bl_buffer[1] == 3 && Utilities.m_flags.bl_buffer[2] == 1 && Utilities.m_flags.bl_buffer[3] == (byte)p_addr)
{
result = true;
}
else
{
for (int i = 0; i < 5; i++)
{
p_data[i] = Utilities.m_flags.bl_buffer[i];
}
}
}
}
p_write_result = flag2;
p_wait_result = flag;
return(result);
}
public static bool Read_One_BL_Flash_USB_Packet(ushort p_addr, byte p_byte_count, ref byte[] p_data)
{
bool flag = false;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 1;
array[2] = p_byte_count;
array[3] = (byte)p_addr;
array[4] = (byte)(p_addr >> 8);
array[5] = 0;
Utilities.m_flags.g_need_to_copy_bl_data = true;
if ((!USBWrite.Send_Data_Packet_To_PICkitS(ref array) || !Utilities.m_flags.g_bl_data_arrived_event.WaitOne(0x3e8, false)) || ((Utilities.m_flags.bl_buffer[1] != 1) || (Utilities.m_flags.bl_buffer[2] != p_byte_count)))
{
return(flag);
}
for (int i = 6; i < (6 + p_byte_count); i++)
{
p_data[i - 6] = Utilities.m_flags.bl_buffer[i];
}
return(true);
}
private static bool Force_PKS_Into_Prog_Mode_Cmd()
{
bool flag = false;
ushort num = 0;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[1] = 0x42;
array[2] = 0;
if (Bootloader.Retrieve_BL_FW_Version_Cmd(ref num))
{
return(true);
}
if (USBWrite.Send_Data_Packet_To_PICkitS(ref array))
{
restart_the_device();
if (Bootloader.Retrieve_BL_FW_Version_Cmd(ref num))
{
flag = true;
}
}
return(flag);
}
public static bool Write_32_Bytes_to_Flash(ushort p_addr, ref byte[] p_data)
{
bool flag = false;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 2;
array[2] = 0x20;
array[3] = (byte)p_addr;
array[4] = (byte)(p_addr >> 8);
array[5] = 0;
for (int i = 0; i < 0x20; i++)
{
array[6 + i] = p_data[i];
}
Utilities.m_flags.g_need_to_copy_bl_data = true;
if (((USBWrite.Send_Data_Packet_To_PICkitS(ref array) && Utilities.m_flags.g_bl_data_arrived_event.WaitOne(0x3e8, false)) && ((Utilities.m_flags.bl_buffer[1] == 2) && (Utilities.m_flags.bl_buffer[2] == 0x20))) && (Utilities.m_flags.bl_buffer[3] == ((byte)p_addr)))
{
flag = true;
}
return(flag);
}
public static bool Read_User_Defined_Sensor_Group(ref byte p_sensor_count, ref byte[] p_sensor_array)
{
byte[] array = new byte[65];
array[0] = 0;
array[1] = 19;
array[2] = 0;
mTouch2.m_user_sensor_values_are_ready.Reset();
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
if (flag)
{
flag = mTouch2.m_user_sensor_values_are_ready.WaitOne(500, false);
if (flag)
{
p_sensor_count = mTouch2.m_user_sensor_values[0];
for (int i = 0; i < (int)p_sensor_count; i++)
{
p_sensor_array[i] = mTouch2.m_user_sensor_values[1 + i];
}
}
}
return(flag);
}
public static bool Read_User_Defined_Sensor_Group(ref byte p_sensor_count, ref byte[] p_sensor_array)
{
byte[] buffer = new byte[0x41];
buffer[0] = 0;
buffer[1] = 0x13;
buffer[2] = 0;
m_user_sensor_values_are_ready.Reset();
bool flag = USBWrite.Send_Data_Packet_To_PICkitS(ref buffer);
if (flag)
{
flag = m_user_sensor_values_are_ready.WaitOne(500, false);
if (!flag)
{
return(flag);
}
p_sensor_count = m_user_sensor_values[0];
for (int i = 0; i < p_sensor_count; i++)
{
p_sensor_array[i] = m_user_sensor_values[1 + i];
}
}
return(flag);
}
public static bool Read_BL_Config_Data(ref byte[] p_data)
{
byte num = 14;
bool flag = false;
byte[] array = new byte[0x41];
Array.Clear(array, 0, array.Length);
array[0] = 0;
array[1] = 6;
array[2] = num;
array[3] = 0;
array[4] = 0;
array[5] = 0x30;
Utilities.m_flags.g_need_to_copy_bl_data = true;
if ((!USBWrite.Send_Data_Packet_To_PICkitS(ref array) || !Utilities.m_flags.g_bl_data_arrived_event.WaitOne(0x3e8, false)) || ((Utilities.m_flags.bl_buffer[1] != 6) || (Utilities.m_flags.bl_buffer[2] != num)))
{
return(flag);
}
for (int i = 6; i < (6 + num); i++)
{
p_data[i - 6] = Utilities.m_flags.bl_buffer[i];
}
return(true);
}
public static bool Add_LIN_Slave_Profile_To_PKS(byte p_array_byte_count, ref byte[] p_profile_array, ref string p_result_str, ref int p_error_code)
{
bool flag = false;
byte[] array = new byte[65];
byte[] array2 = new byte[255];
byte[] array3 = new byte[65];
bool result = false;
byte b = 0;
byte b2 = 0;
string text = "";
p_error_code = 0;
Array.Clear(array, 0, array.Length);
Array.Clear(array3, 0, array3.Length);
byte b3 = LIN.Number_Of_Bytes_In_CBUF3(ref b, ref b2);
if (p_array_byte_count > b3)
{
p_result_str = string.Format("Byte count of {0} greater than allowed value of {1}.", p_array_byte_count, b3);
p_error_code = 1;
return(flag);
}
USBWrite.Clear_CBUF(3);
if (!Basic.Get_Status_Packet(ref array3))
{
p_result_str = string.Format("Error reading status packet.", new object[0]);
p_error_code = 2;
return(false);
}
byte[] expr_A6_cp_0 = array3;
int expr_A6_cp_1 = 23;
expr_A6_cp_0[expr_A6_cp_1] |= 32;
USBWrite.configure_outbound_control_block_packet(ref array, ref text, ref array3);
flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
Array.Clear(array2, 0, array2.Length);
array2[0] = 0;
array2[1] = 5;
array2[2] = p_array_byte_count;
for (int i = 3; i < (int)(p_array_byte_count + 3); i++)
{
array2[i] = p_profile_array[i - 3];
}
bool flag2 = USBWrite.Send_Script_To_PICkitS(ref array2);
if (flag & flag2)
{
if (USBWrite.Update_Status_Packet())
{
Utilities.m_flags.g_status_packet_mutex.WaitOne();
int j;
for (j = 7; j < 31; j++)
{
if (Constants.STATUS_PACKET_DATA[j] != array[j - 5])
{
p_error_code = 3;
p_result_str = string.Format("Byte {0} failed verification in config block write.\n Value reads {1:X2}, but should be {2:X2}.", j - 7, Constants.STATUS_PACKET_DATA[j], array[j - 5]);
break;
}
}
if (j == 31)
{
result = true;
p_result_str = string.Format("PICkit Serial Analyzer correctly updated.", new object[0]);
}
Utilities.m_flags.g_status_packet_mutex.ReleaseMutex();
}
else
{
p_result_str = string.Format("Error requesting config verification - Config Block may not be updated correctly", new object[0]);
}
}
else
{
p_error_code = 2;
p_result_str = string.Format("Error sending config packet - Config Block may not be updated correctly", new object[0]);
}
return(result);
}
public static bool Add_LIN_Slave_Profile_To_PKS(byte p_array_byte_count, ref byte[] p_profile_array, ref string p_result_str, ref int p_error_code)
{
bool flag = false;
byte[] array = new byte[0x41];
byte[] buffer2 = new byte[0xff];
byte[] buffer3 = new byte[0x41];
bool flag2 = false;
byte num = 0;
byte num2 = 0;
string str = "";
int index = 0;
p_error_code = 0;
Array.Clear(array, 0, array.Length);
Array.Clear(buffer3, 0, buffer3.Length);
byte num4 = Number_Of_Bytes_In_CBUF3(ref num, ref num2);
if (p_array_byte_count > num4)
{
p_result_str = string.Format("Byte count of {0} greater than allowed value of {1}.", p_array_byte_count, num4);
p_error_code = 1;
return(flag);
}
USBWrite.Clear_CBUF(3);
if (!Basic.Get_Status_Packet(ref buffer3))
{
p_result_str = string.Format("Error reading status packet.", new object[0]);
p_error_code = 2;
return(false);
}
buffer3[0x17] = (byte)(buffer3[0x17] | 0x20);
USBWrite.configure_outbound_control_block_packet(ref array, ref str, ref buffer3);
flag = USBWrite.Send_Data_Packet_To_PICkitS(ref array);
Array.Clear(buffer2, 0, buffer2.Length);
buffer2[0] = 0;
buffer2[1] = 5;
buffer2[2] = p_array_byte_count;
for (int i = 3; i < (p_array_byte_count + 3); i++)
{
buffer2[i] = p_profile_array[i - 3];
}
bool flag3 = USBWrite.Send_Script_To_PICkitS(ref buffer2);
if (!(flag & flag3))
{
p_error_code = 2;
p_result_str = string.Format("Error sending config packet - Config Block may not be updated correctly", new object[0]);
return(flag2);
}
if (!USBWrite.Update_Status_Packet())
{
p_result_str = string.Format("Error requesting config verification - Config Block may not be updated correctly", new object[0]);
return(flag2);
}
Utilities.m_flags.g_status_packet_mutex.WaitOne();
index = 7;
while (index < 0x1f)
{
if (Constants.STATUS_PACKET_DATA[index] != array[index - 5])
{
p_error_code = 3;
p_result_str = string.Format("Byte {0} failed verification in config block write.\n Value reads {1:X2}, but should be {2:X2}.", index - 7, Constants.STATUS_PACKET_DATA[index], array[index - 5]);
break;
}
index++;
}
if (index == 0x1f)
{
flag2 = true;
p_result_str = string.Format("PICkit Serial Analyzer correctly updated.", new object[0]);
}
Utilities.m_flags.g_status_packet_mutex.ReleaseMutex();
return(flag2);
}
public static bool Send_Script_To_PICkitS(ref byte[] p_send_byte_array)
{
bool result;
lock (USBWrite.m_priv_write_script_lock)
{
USBWrite.m_data_buffer_is_empty = false;
bool flag = false;
uint num = 0u;
uint num2 = (uint)p_send_byte_array[2];
byte[] array = new byte[65];
USBWrite.m_last_script_array_mutex.WaitOne();
USBWrite.m_last_script_array_byte_count = (byte)(num2 + 2u);
Array.Clear(USBWrite.m_last_script_array, 0, USBWrite.m_last_script_array.Length);
for (int i = 0; i < (int)USBWrite.m_last_script_array_byte_count; i++)
{
USBWrite.m_last_script_array[i] = p_send_byte_array[i + 1];
}
Utilities.m_flags.g_PKSA_has_completed_script.Reset();
USBWrite.m_last_script_array_mutex.ReleaseMutex();
uint num3 = num2 / 62u;
byte b = (byte)(num2 % 62u);
if (b != 0)
{
num3 += 1u;
}
int num4 = 0;
while ((long)num4 < (long)((ulong)num3))
{
Array.Clear(array, 0, array.Length);
array[0] = p_send_byte_array[0];
array[1] = p_send_byte_array[1];
uint num5;
uint num6;
if (num3 != 1u)
{
num5 = 3u;
if ((long)num4 == (long)((ulong)(num3 - 1u)) && b != 0)
{
num6 = (uint)(b + 4);
array[2] = b;
}
else
{
num6 = 65u;
array[2] = 62;
}
}
else
{
num6 = num2 + 4u;
num5 = 2u;
}
for (uint num7 = num5; num7 < num6; num7 += 1u)
{
array[(int)((UIntPtr)num7)] = p_send_byte_array[(int)((UIntPtr)(num + num7))];
}
if (num3 != 1u)
{
num += 62u;
if ((long)num4 == (long)((ulong)(num3 - 1u)))
{
num += 1u;
}
}
if (array[1] == 3)
{
if (!USBWrite.there_is_room_in_cbuf1(array[2]))
{
result = false;
return(result);
}
USBWrite.m_cbuf1_avail_bytes_mutex.WaitOne();
USBWrite.m_cbuf1_avail_bytes -= array[2];
USBWrite.m_cbuf1_avail_bytes_mutex.ReleaseMutex();
if (!USBWrite.Send_Data_Packet_To_PICkitS(ref array))
{
result = false;
return(result);
}
if (USBWrite.There_Was_A_Write_Error())
{
result = false;
return(result);
}
}
else
{
if (!USBWrite.Send_Data_Packet_To_PICkitS(ref array))
{
result = false;
return(result);
}
if (USBWrite.There_Was_A_Write_Error())
{
result = false;
return(result);
}
}
num4++;
}
if (array[1] == 3)
{
if (USBWrite.m_use_script_timeout)
{
bool flag2 = Utilities.m_flags.g_PKSA_has_completed_script.WaitOne(USBWrite.m_universal_timeout, false);
if (flag2 && USBWrite.Update_Status_Packet())
{
uint num8 = 0u;
if (!Status.There_Is_A_Status_Error(ref num8))
{
flag = true;
}
}
}
else
{
flag = true;
}
}
else
{
flag = true;
}
USBWrite.m_data_buffer_is_empty = true;
result = flag;
}
return(result);
}
