// BlueFlashToolDlg.cpp : implementation file
//

#include "stdafx.h"
#include "BlueFlashTool.h"
#include "BlueFlashToolDlg.h"
#include "SysConfig.h"
#include "DBT.H"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CBlueFlashToolDlg dialog





UINT BlueFlashThreadProc(LPVOID lParam);

CBlueFlashToolDlg::CBlueFlashToolDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CBlueFlashToolDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CBlueFlashToolDlg)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
	memset(ifUartEnable,0,BLUE_TYPE_MAX*MAX_TOPWELL_DEVICE_NUM);
	memcpy(strSignalFlashReady,"ROM boot",16);
	memcpy(strSignalFlashing,"Programming:97",20);
	mystrAppcurrDir = GetCurrPath();
}

void CBlueFlashToolDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CBlueFlashToolDlg)
	DDX_Control(pDX, IDC_MSCOMM0, mycom_debug);
	DDX_Control(pDX, IDC_MSCOMM1,  mycom[0][0]);
	DDX_Control(pDX, IDC_MSCOMM2,  mycom[0][1]);
	DDX_Control(pDX, IDC_MSCOMM3,  mycom[0][2]);
	DDX_Control(pDX, IDC_MSCOMM4,  mycom[0][3]);
	DDX_Control(pDX, IDC_MSCOMM5,  mycom[0][4]);
	DDX_Control(pDX, IDC_MSCOMM6,  mycom[0][5]);
	DDX_Control(pDX, IDC_MSCOMM7,  mycom[0][6]);
	DDX_Control(pDX, IDC_MSCOMM8,  mycom[0][7]);
	DDX_Control(pDX, IDC_MSCOMM9,  mycom[0][8]);
	DDX_Control(pDX, IDC_MSCOMM10, mycom[0][9]);
	DDX_Control(pDX, IDC_MSCOMM11, mycom[0][10]);
	DDX_Control(pDX, IDC_MSCOMM12, mycom[0][11]);
	DDX_Control(pDX, IDC_MSCOMM13, mycom[0][12]);
	DDX_Control(pDX, IDC_MSCOMM14, mycom[0][13]);
	DDX_Control(pDX, IDC_MSCOMM15, mycom[0][14]);
	DDX_Control(pDX, IDC_MSCOMM16, mycom[0][15]);
	DDX_Control(pDX, IDC_MSCOMM17, mycom[0][16]);
	DDX_Control(pDX, IDC_MSCOMM18, mycom[0][17]);
	DDX_Control(pDX, IDC_MSCOMM19, mycom[0][18]);
	DDX_Control(pDX, IDC_MSCOMM20, mycom[0][19]);
	DDX_Control(pDX, IDC_MSCOMM21, mycom[0][20]);
	DDX_Control(pDX, IDC_MSCOMM22, mycom[0][21]);
	DDX_Control(pDX, IDC_MSCOMM23, mycom[0][22]);
	DDX_Control(pDX, IDC_MSCOMM24, mycom[0][23]);
	DDX_Control(pDX, IDC_MSCOMM25, mycom[0][24]);
	DDX_Control(pDX, IDC_MSCOMM26, mycom[1][0]);
	DDX_Control(pDX, IDC_MSCOMM27, mycom[1][1]);
	DDX_Control(pDX, IDC_MSCOMM28, mycom[1][2]);
	DDX_Control(pDX, IDC_MSCOMM29, mycom[1][3]);
	DDX_Control(pDX, IDC_MSCOMM30, mycom[1][4]);
	DDX_Control(pDX, IDC_MSCOMM31, mycom[1][5]);
	DDX_Control(pDX, IDC_MSCOMM32, mycom[1][6]);
	DDX_Control(pDX, IDC_MSCOMM33, mycom[1][7]);
	DDX_Control(pDX, IDC_MSCOMM34, mycom[1][8]);
	DDX_Control(pDX, IDC_MSCOMM35, mycom[1][9]);
	DDX_Control(pDX, IDC_MSCOMM36, mycom[1][10]);
	DDX_Control(pDX, IDC_MSCOMM37, mycom[1][11]);
	DDX_Control(pDX, IDC_MSCOMM38, mycom[1][12]);
	DDX_Control(pDX, IDC_MSCOMM39, mycom[1][13]);
	DDX_Control(pDX, IDC_MSCOMM40, mycom[1][14]);
	DDX_Control(pDX, IDC_MSCOMM41, mycom[1][15]);
	DDX_Control(pDX, IDC_MSCOMM42, mycom[1][16]);
	DDX_Control(pDX, IDC_MSCOMM43, mycom[1][17]);
	DDX_Control(pDX, IDC_MSCOMM44, mycom[1][18]);
	DDX_Control(pDX, IDC_MSCOMM45, mycom[1][19]);
	DDX_Control(pDX, IDC_MSCOMM46, mycom[1][20]);
	DDX_Control(pDX, IDC_MSCOMM47, mycom[1][21]);
	DDX_Control(pDX, IDC_MSCOMM48, mycom[1][22]);
	DDX_Control(pDX, IDC_MSCOMM49, mycom[1][23]);
	DDX_Control(pDX, IDC_MSCOMM50, mycom[1][24]);
//	DDX_Control(pDX, IDC_MSCOMM1,  mycom01);
//	DDX_Control(pDX, IDC_MSCOMM2,  mycom02);
//	DDX_Control(pDX, IDC_MSCOMM3,  mycom03);
//	DDX_Control(pDX, IDC_MSCOMM4,  mycom04);
//	DDX_Control(pDX, IDC_MSCOMM5,  mycom05);
//	DDX_Control(pDX, IDC_MSCOMM6,  mycom06);
//	DDX_Control(pDX, IDC_MSCOMM7,  mycom07);
//	DDX_Control(pDX, IDC_MSCOMM8,  mycom08);
//	DDX_Control(pDX, IDC_MSCOMM9,  mycom09);
//	DDX_Control(pDX, IDC_MSCOMM10, mycom10);
//	DDX_Control(pDX, IDC_MSCOMM11, mycom11);
//	DDX_Control(pDX, IDC_MSCOMM12, mycom12);
//	DDX_Control(pDX, IDC_MSCOMM13, mycom13);
//	DDX_Control(pDX, IDC_MSCOMM14, mycom14);
//	DDX_Control(pDX, IDC_MSCOMM15, mycom15);
//	DDX_Control(pDX, IDC_MSCOMM16, mycom16);
//	DDX_Control(pDX, IDC_MSCOMM17, mycom17);
//	DDX_Control(pDX, IDC_MSCOMM18, mycom18);
//	DDX_Control(pDX, IDC_MSCOMM19, mycom19);
//	DDX_Control(pDX, IDC_MSCOMM20, mycom20);
//	DDX_Control(pDX, IDC_MSCOMM21, mycom21);
//	DDX_Control(pDX, IDC_MSCOMM22, mycom22);
//	DDX_Control(pDX, IDC_MSCOMM23, mycom23);
//	DDX_Control(pDX, IDC_MSCOMM24, mycom24);
//	DDX_Control(pDX, IDC_MSCOMM25, mycom25);
//	DDX_Control(pDX, IDC_MSCOMM26, mycom26);
//	DDX_Control(pDX, IDC_MSCOMM27, mycom27);
//	DDX_Control(pDX, IDC_MSCOMM28, mycom28);
//	DDX_Control(pDX, IDC_MSCOMM29, mycom29);
//	DDX_Control(pDX, IDC_MSCOMM30, mycom30);
//	DDX_Control(pDX, IDC_MSCOMM31, mycom31);
//	DDX_Control(pDX, IDC_MSCOMM32, mycom32);
//	DDX_Control(pDX, IDC_MSCOMM33, mycom33);
//	DDX_Control(pDX, IDC_MSCOMM34, mycom34);
//	DDX_Control(pDX, IDC_MSCOMM35, mycom35);
//	DDX_Control(pDX, IDC_MSCOMM36, mycom36);
//	DDX_Control(pDX, IDC_MSCOMM37, mycom37);
//	DDX_Control(pDX, IDC_MSCOMM38, mycom38);
//	DDX_Control(pDX, IDC_MSCOMM39, mycom39);
//	DDX_Control(pDX, IDC_MSCOMM40, mycom40);
//	DDX_Control(pDX, IDC_MSCOMM41, mycom41);
//	DDX_Control(pDX, IDC_MSCOMM42, mycom42);
//	DDX_Control(pDX, IDC_MSCOMM43, mycom43);
//	DDX_Control(pDX, IDC_MSCOMM44, mycom44);
//	DDX_Control(pDX, IDC_MSCOMM45, mycom45);
//	DDX_Control(pDX, IDC_MSCOMM46, mycom46);
//	DDX_Control(pDX, IDC_MSCOMM47, mycom47);
//	DDX_Control(pDX, IDC_MSCOMM48, mycom48);
//	DDX_Control(pDX, IDC_MSCOMM49, mycom49);
//	DDX_Control(pDX, IDC_MSCOMM50, mycom50);

	//}}AFX_DATA_MAP
	DDX_Control(pDX, IDC_DEBUG_MESSAGE, mylistDebugInfo);
}

BEGIN_MESSAGE_MAP(CBlueFlashToolDlg, CDialog)
	//{{AFX_MSG_MAP(CBlueFlashToolDlg)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON_SETTING, OnButtonSetting)
	//}}AFX_MSG_MAP
	ON_BN_CLICKED(IDC_BUTTON_INIT_COMPORT, &CBlueFlashToolDlg::OnBnClickedButtonInitComport)

	ON_WM_DESTROY()
	ON_BN_CLICKED(IDC_START_ALL, &CBlueFlashToolDlg::OnBnClickedStartAll)
	ON_BN_CLICKED(IDC_STOP_ALL, &CBlueFlashToolDlg::OnBnClickedStopAll)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CBlueFlashToolDlg message handlers

BOOL CBlueFlashToolDlg::OnInitDialog()
{
	int loop1,loop2,loop3;
	RECT rect_pcb[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	//RECT rect_check[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	RECT rect_comport[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	RECT rect_process_bar[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	RECT rect_start_button[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	RECT rect_SN_info[BLUE_TYPE_MAX][MAX_TOPWELL_DEVICE_NUM];
	RECT rect_this;
	CString m_strSettings;
	
	CDialog::OnInitDialog();

#ifdef __TOPWELL_EDIT_SN_ENABLE__
	mybufferForFile = new BYTE [1024*1024*2];
	mybufferForFileUSB = new BYTE [1024*1024*2];
	LoadBin((int)BLUE_TYPE_EAR);
	LoadBin((int)BLUE_TYPE_USB);
#endif
	GetWindowRect(&rect_this);
	myfontButton.CreateFont( 18,0,0,0,FW_NORMAL|FW_BOLD,FALSE,FALSE,0,DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
		DEFAULT_PITCH | FF_MODERN,_T("宋体") ) ;
	//QuerySerialPortStatusEx(myAryExistPort,myAryNoneOpenedPort,myAryAlreadyOpenedPort,myAryNotExistPort,1,254);

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	myBitmapWait = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP_RED));
	myBitmapReady = ::LoadBitmap(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_BITMAP_GREEN));

	m_strSettings.Format("%d,n,8,1", g_AppMainData.com_config.aBandrate);

	for (loop1 = 0;loop1<BLUE_TYPE_MAX; loop1++)
	{
		for (loop2 = 0;loop2 <MAX_TOPWELL_DEVICE_NUM;loop2++)
		{
			rect_pcb[loop1][loop2].left = 10+400*loop1;
			rect_comport[loop1][loop2].left = 30+400*loop1;
			rect_process_bar[loop1][loop2].left = 110+400*loop1;
			rect_start_button[loop1][loop2].left = 230+400*loop1;
			rect_SN_info[loop1][loop2].left = 280+400*loop1;;


			rect_pcb[loop1][loop2].right= rect_pcb[loop1][loop2].left+15;
			rect_comport[loop1][loop2].right = rect_comport[loop1][loop2].left+70;
			rect_process_bar[loop1][loop2].right = rect_process_bar[loop1][loop2].left+100;
			rect_start_button[loop1][loop2].right = rect_start_button[loop1][loop2].left+40;
			rect_SN_info[loop1][loop2].right = rect_SN_info[loop1][loop2].left+100;

			rect_pcb[loop1][loop2].top = 30+25*loop2;
			rect_comport[loop1][loop2].top = 30+25*loop2;
			rect_process_bar[loop1][loop2].top = 30+25*loop2;
			rect_start_button[loop1][loop2].top = 30+25*loop2;
			rect_SN_info[loop1][loop2].top = 30+25*loop2;

			rect_pcb[loop1][loop2].bottom= rect_pcb[loop1][loop2].top+20;
			rect_comport[loop1][loop2].bottom = rect_comport[loop1][loop2].top+200;
			rect_process_bar[loop1][loop2].bottom = rect_process_bar[loop1][loop2].top+20;
			rect_start_button[loop1][loop2].bottom = rect_start_button[loop1][loop2].top+20;
			rect_SN_info[loop1][loop2].bottom = rect_SN_info[loop1][loop2].top+20;



			//PCB LED
			myctrlPcbState[loop1][loop2].Create(NULL, SS_BITMAP |WS_CHILD|WS_VISIBLE,
				rect_pcb[loop1][loop2],
				this,
				IDC_PCB_STATE1+loop1*MAX_TOPWELL_DEVICE_NUM+loop2);
			myctrlPcbState[loop1][loop2].SetBitmap(myBitmapWait);
			//COM port list
			myctrlComboComPort[loop1][loop2].Create( WS_CHILD|WS_VISIBLE|WS_VSCROLL|CBS_DROPDOWNLIST,
				rect_comport[loop1][loop2],this,IDC_UART_CONFIG1+loop1*MAX_TOPWELL_DEVICE_NUM+loop2);
			// Create a smooth child progress control.
			myctrlProcess[loop1][loop2].Create(WS_CHILD|WS_VISIBLE|PBS_SMOOTH, rect_process_bar[loop1][loop2], 
				this, IDC_PROGRESS_FLASH0+loop1*MAX_TOPWELL_DEVICE_NUM+loop2); 

			// Create a push button.
			myctrlStartButton[loop1][loop2].Create("开始",WS_VISIBLE|BS_PUSHBUTTON,
			   rect_start_button[loop1][loop2], this, IDC_BUTTON_START0+loop1*MAX_TOPWELL_DEVICE_NUM+loop2);
			myctrlStartButton[loop1][loop2].EnableWindow(FALSE);
			myStaticSn[loop1][loop2].Create("文件名",WS_BORDER|WS_CHILD|WS_VISIBLE, rect_SN_info[loop1][loop2], 
			this, IDC_STATIC_GROUP0+loop1*MAX_TOPWELL_DEVICE_NUM+loop2); 
		}
	}
	//WM_DEVICECHANGE

	GetDlgItem(IDC_STATIC_GROUP_DEBUG_INFO)->MoveWindow(0,rect_pcb[0][loop2-1].bottom+10,
		rect_SN_info[loop1-1][loop2-1].right+250,310);
	GetDlgItem(IDC_STATIC_GROUP_DEBUG_INFO)->SetWindowText("运行日志");
	mylistDebugInfo.MoveWindow(rect_pcb[0][loop2-1].left,rect_pcb[0][loop2-1].bottom+30,
		rect_SN_info[loop1-1][loop2-1].right+230,300);

	GetDlgItem(IDC_STATIC_GROUP_EAR)->MoveWindow(0,5,
		rect_SN_info[0][loop2-1].right+15,
		rect_SN_info[0][loop2-1].bottom+2);
	GetDlgItem(IDC_STATIC_GROUP_EAR)->SetWindowText("耳机下载");
	GetDlgItem(IDC_STATIC_GROUP_USB)->MoveWindow(rect_pcb[loop1-1][0].left-10,5,
		rect_SN_info[0][loop2-1].right+10,
		rect_SN_info[0][loop2-1].bottom+2);
	GetDlgItem(IDC_STATIC_GROUP_USB)->SetWindowText("发射器下载");

	

	GetDlgItem(IDC_START_ALL)->MoveWindow(
		rect_SN_info[loop1-1][loop2-1].right+50,
		rect_SN_info[0][0].top+20,
		100,50);
	GetDlgItem(IDC_STOP_ALL)->MoveWindow(
		rect_SN_info[loop1-1][loop2-1].right+50,
		rect_SN_info[0][0].top+90,
		100,50);
	GetDlgItem(IDC_BUTTON_INIT_COMPORT)->MoveWindow(
		rect_SN_info[loop1-1][loop2-1].right+50,
		rect_SN_info[loop1-1][loop2-1].bottom-140,
		100,50);
	GetDlgItem(IDC_BUTTON_SETTING)->MoveWindow(
		rect_SN_info[loop1-1][loop2-1].right+50,
		rect_SN_info[loop1-1][loop2-1].bottom-70,
		100,50);

	GetDlgItem(IDC_START_ALL)->SetFont(&myfontButton);
	GetDlgItem(IDC_STOP_ALL)->SetFont(&myfontButton);
	GetDlgItem(IDC_BUTTON_INIT_COMPORT)->SetFont(&myfontButton);
	GetDlgItem(IDC_BUTTON_SETTING)->SetFont(&myfontButton);
	rect_this.right = rect_this.left + rect_SN_info[loop1-1][loop2-1].right+260;
	rect_this.bottom = rect_this.top + rect_pcb[0][loop2-1].bottom+350;
	MoveWindow(&rect_this);

	myAryFlashSuc.RemoveAll();
	if (g_AppMainData.firstID_binfile == g_AppMainData.lastID_binfile)
	{
		for (loop1 = 0; loop1 < 30000+1; loop1++)
			myAryFlashFail.Add(0);
	}
	else
	{
		for (loop1 = g_AppMainData.firstID_binfile; loop1 < g_AppMainData.lastID_binfile+1; loop1++)
			myAryFlashFail.Add(loop1);
	}




	UartDeviceChange();

	UpdateGroupsCaptions();
	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CBlueFlashToolDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CBlueFlashToolDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CBlueFlashToolDlg::OnButtonSetting() 
{
	CSysConfig dlg;
	dlg.DoModal();
#ifdef __TOPWELL_EDIT_SN_ENABLE__
	LoadBin((int)BLUE_TYPE_EAR);
	LoadBin((int)BLUE_TYPE_USB);
#endif
	UpdateGroupsCaptions();

}

void CBlueFlashToolDlg::UpdateGroupsCaptions()
{
	CString 		strCaptionStatics;
	int 			loop1 = 0,loop2 = 0;
	int 			binEarFileindex =0;
	//int 			binUsbFileindex = g_AppMainData.LastUsbBin;
	int			sumPort = 0,sumForSn = 0;
	CButton *		pbutton;

	for (loop2 = 0; loop2 < MAX_TOPWELL_DEVICE_NUM; loop2++)
	{
		for (loop1 = 0; loop1 < BLUE_TYPE_MAX; loop1++)
		{
 			//if (g_AppMainData.ary_myComPort[loop1][loop2] >1)
			sumPort += ifUartEnable[loop1][loop2];
			if (ifUartEnable[loop1][loop2])
 			{
				if (BLUE_TYPE_EAR== loop1)
					strCaptionStatics.Format("RX_%04d.bin",myAryFlashFail.GetAt(binEarFileindex));
				else
					strCaptionStatics.Format("TX_%04d.bin",myAryFlashFail.GetAt(binEarFileindex));
				myStaticSn[loop1][loop2].SetWindowText(strCaptionStatics);
				myctrlStartButton[loop1][loop2].EnableWindow(TRUE);
 			}
 			else 
 			{
				myStaticSn[loop1][loop2].SetWindowText("无文件");
				myctrlStartButton[loop1][loop2].EnableWindow(FALSE);
 			}


		}
	}
	GetDlgItem(IDC_START_ALL)->EnableWindow(sumPort> 0 ? TRUE: FALSE);
}


BEGIN_EVENTSINK_MAP(CBlueFlashToolDlg, CDialog)
	ON_EVENT(CBlueFlashToolDlg, IDC_MSCOMM0, 1, CBlueFlashToolDlg::OnCommMscommDebug, VTS_NONE)
	//ON_EVENT(CBlueFlashToolDlg, IDC_MSCOMM1, 1, CBlueFlashToolDlg::OnCommMscomm1, VTS_NONE)
	ON_EVENT_RANGE(CBlueFlashToolDlg, IDC_MSCOMM1,IDC_MSCOMM1+50, 1 /* OnComm */, OnCommMscomm1,  VTS_I4 )  
END_EVENTSINK_MAP()


void CBlueFlashToolDlg::OnCommMscommDebug()
{
	// TODO: Add your message handler code here
}
void CBlueFlashToolDlg::OnBnClickedButtonInitComport()
{
	int 			loop1 = 0, loop2 = 0;
	CString strButtonText;
	GetDlgItem(IDC_BUTTON_INIT_COMPORT)->GetWindowText(strButtonText);
	if (strButtonText == "连接夹具")
	{
		for (loop1 = 0; loop1 < BLUE_TYPE_MAX; loop1++)
		{
			for (loop2 = 0; loop2 < MAX_TOPWELL_DEVICE_NUM; loop2++)
			{
				OpenComport(loop1, loop2);
			}
		}
		GetDlgItem(IDC_BUTTON_INIT_COMPORT)->SetWindowText("断开夹具");
	} 
	else
	{
		for (loop1 = 0; loop1 < BLUE_TYPE_MAX; loop1++)
		{
			for (loop2 = 0; loop2 < MAX_TOPWELL_DEVICE_NUM; loop2++)
			{
				CloseComport(loop1, loop2);
			}
		}
		GetDlgItem(IDC_BUTTON_INIT_COMPORT)->SetWindowText("连接夹具");
	}
	UpdateGroupsCaptions();
}



void CBlueFlashToolDlg::OnDestroy()
{
	CDialog::OnDestroy();
#ifdef __TOPWELL_EDIT_SN_ENABLE__
	delete mybufferForFile;
#endif
	//myAryFlashFail.Serialize();
	g_pmainapp->SaveConfigs();
}

// 打开COM口，
bool CBlueFlashToolDlg::OpenComport(int earOrUsb, int index)
{
	int loop = 0;
	CString m_strSettings;
	int comopen_port;
	//CMSComm *pctrlComToOpen = pctrlMSComm[earOrUsb][index];
	m_strSettings.Format("%d,n,8,1", g_AppMainData.com_config.aBandrate);
	comopen_port =g_AppMainData.ary_myComPort[earOrUsb][index] ;
	if (comopen_port<2) 
	{
		return false;
	}
	DBG_print("[%d]开始打开端口 %d",__LINE__,comopen_port);
	if (QuerySingleSerialPortEx(comopen_port) != TRUE)
	{
		DBG_print("[%d]已被占用 %d",__LINE__,comopen_port);
		g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][loop]=0;
		ifUartEnable[earOrUsb][index] = false;
		return false;
	}
	if (mycom[earOrUsb][index].GetPortOpen())
	{
		if (mycom[earOrUsb][index].GetCommPort() == comopen_port)
		{
			DBG_print("[%d]该串口已打开，请勿重复打开！\r\n",__LINE__);
			return TRUE;
		}
	}
	mycom[earOrUsb][index].SetCommPort(g_AppMainData.ary_myComPort[earOrUsb][index]); //选择com1
	mycom[earOrUsb][index].SetInputMode(1);
	mycom[earOrUsb][index].SetInputLen(BLUE_UART_INPUTBUFFER_SIZE);				//设置当前接收区数据长度为0
	mycom[earOrUsb][index].SetOutBufferSize(512);
	mycom[earOrUsb][index].SetSettings(m_strSettings); //波特率9600，无校验，8个数据位，1个停止位


	if (!mycom[earOrUsb][index].GetPortOpen())
	{
			try
			{
				mycom[earOrUsb][index].SetPortOpen(TRUE); //打开串口
			}
			catch (CException* e)
			{
				e->ReportError(MB_ICONSTOP);
				return FALSE;
			}
			mycom[earOrUsb][index].SetRThreshold(1);
			ifUartEnable[earOrUsb][index] = true;
			DBG_print("[%d]串口打开成功 %d",__LINE__,comopen_port);
	}
	else 
	{
		DBG_print("[%d]串口%d无法打开",__LINE__,comopen_port );
		g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][loop]=0;
		ifUartEnable[earOrUsb][index] = false;
	}
	mycom[earOrUsb][index].GetInput();					//先预读缓冲区以清除残留数据	
	return true;
}



// 打开COM口，
bool CBlueFlashToolDlg::CloseComport(int earOrUsb, int index)
{
	int loop = 0;
	CString m_strSettings;
	int comopen_port;
	comopen_port =g_AppMainData.ary_myComPort[earOrUsb][index] ;
	if (comopen_port<2) return false;
	try
	{
		if (mycom[earOrUsb][index].GetPortOpen())
			mycom[earOrUsb][index].SetPortOpen(FALSE);
		ifUartEnable[earOrUsb][index] = false;
	}
	catch (CException* e)
	{
		e->ReportError();
		return FALSE;
	}
	return true;
}




int CBlueFlashToolDlg::DBG_print(const char * strMsg, ...)
{
    int var_tickcount = 0;
    int iRet = 0;
    char szBuf[256] = "";
    va_list varg;
	CString atime;

    va_start(varg, strMsg);
    vsprintf(szBuf, strMsg, varg);
    //iRet = vsprintf_s(szBuf, strMsg, varg);
    va_end(varg);
	var_tickcount = GetTickCount();
	mylistDebugInfo.SetCurSel(mylistDebugInfo.AddString(szBuf));
    return iRet;
}


void CBlueFlashToolDlg::OnCommMscomm1(UINT nID)
{
	// TODO: Add your control notification handler code here
	CMSComm * apctrlMSComm;
	VARIANT 		variant_inp_com_msg;
	COleSafeArray	safearray_inp;
	LONG			len, k;
	int aDeviceType ;//设备类型
	int aIndex;		//设备索引
	//char flash_process[4];
	char message_rev[BLUE_UART_INPUTBUFFER_SIZE];
	char onecharOfBuf;
	char *pmybufferFromUart;
	memset(message_rev,0,BLUE_UART_INPUTBUFFER_SIZE);
	aDeviceType = (nID - IDC_MSCOMM1)/MAX_TOPWELL_DEVICE_NUM;
	aIndex = (nID - IDC_MSCOMM1)%MAX_TOPWELL_DEVICE_NUM;
	pmybufferFromUart = (char *)mybufferFromUart[aDeviceType][aIndex];
	if (strlen(pmybufferFromUart) >= BLUE_UART_INPUTBUFFER_SIZE)
		memset(pmybufferFromUart,0,BLUE_UART_INPUTBUFFER_SIZE);
	if (mycom[aDeviceType][aIndex].GetCommEvent() == 2) //事件值为2表示接收缓冲区内有字符
	{
		variant_inp_com_msg = mycom[aDeviceType][aIndex].GetInput(); 	//读缓冲区
		safearray_inp		= variant_inp_com_msg;			//VARIANT型变量转换为ColeSafeArray型变量
		len 				= safearray_inp.GetOneDimSize(); //得到有效数据长度
		for (k = 0; k < len; k++)
		{
				safearray_inp.GetElement(&k, &onecharOfBuf);
				if (onecharOfBuf != 0 && onecharOfBuf != 10)
				{//把UART接收缓冲区的一个非零字节保存下来					
					pmybufferFromUart[strlen(pmybufferFromUart)] = onecharOfBuf;
				}
				else
				{// 如果UART缓冲区的这个字节是0, 则表示结束 , 开始解析该命令
					if (strlen(pmybufferFromUart))
						strcpy(message_rev,pmybufferFromUart);
					memset(pmybufferFromUart,0,BLUE_UART_INPUTBUFFER_SIZE);
				}
		}
		//  最后一个字符没有结尾, 接着读下一次UART的缓冲区
		if (onecharOfBuf != 0 && onecharOfBuf != 10)
			return;
		//pmessage_rev = safearray_inp.;
		if (strlen(message_rev) == 0) 
		{
			myctrlPcbState[aDeviceType][aIndex].SetBitmap(myBitmapWait);
			return;
		}
		DBG_print("线路 %d  %s",g_AppMainData.ary_myComPort[aDeviceType][aIndex],message_rev);
		if(strstr(message_rev, strSignalFlashReady) != NULL)
		{
			CString strtmsg;
			myctrlPcbState[aDeviceType][aIndex].SetBitmap(myBitmapReady);

			myStaticSn[aDeviceType][aIndex].GetWindowText(strtmsg);
			myThreadData[aDeviceType][aIndex].Filename = mystrAppcurrDir+"Bins\\ear\\"+strtmsg;

			mytickcount[aDeviceType][aIndex] = GetTickCount();
			myThreadData[aDeviceType][aIndex].pDlg = this;
			myThreadData[aDeviceType][aIndex].blue_device_type = (BYTE)aDeviceType;
			myThreadData[aDeviceType][aIndex].nIndex = aIndex;
			myThreadData[aDeviceType][aIndex].StartThread = BLUE_THREAD_READY;
			myThreadData[aDeviceType][aIndex].pctrlMSComm = &mycom[aDeviceType][aDeviceType];
			myThreadData[aDeviceType][aIndex].m_hThread = AfxBeginThread(BlueFlashThreadProc, &myThreadData[aDeviceType][aIndex]);
			myctrlStartButton[aDeviceType][aIndex].SetWindowText("停止");
		}
		else if (strstr((char *)message_rev,strSignalFlashing) != NULL)
		{
			myctrlProcess[aDeviceType][aIndex].SetPos(atoi(message_rev+12)*10);
		}
		else
		{
			DBG_print("线路 %d  %s",g_AppMainData.ary_myComPort[aDeviceType][aIndex],message_rev);
			myctrlPcbState[aDeviceType][aIndex].SetBitmap(myBitmapWait);
		}
	}
}


UINT BlueFlashThreadProc(LPVOID lParam)
{
	FLASH_THREAD_DATA* pThreadData = (FLASH_THREAD_DATA*)lParam;
	BLUE_DEVICE_TYPE aDeviceType ;//设备类型
	int aIndex;		//设备索引
	BYTE			ByteBuf_512[1 * 512];	//每次读取文件buf为512
	CByteArray		ByteArray_512;			//每次发送文件array为512
	DWORD Length;				//文件长度
	int numParts;// 文件被分割的块数
	int Partsremain ;// 按512分割之后的尾数
	int loop;		//循环读取文件的计数器
	CMSComm *pctrlMSComm;
	CFile MyFile1;
	BOOL res_openfile;
	

	if(lParam == NULL) 
	{
		pThreadData->StartThread = BLUE_THREAD_STOP;
		return -1;		//如果线程参数位空, 直接退出
	}
	pThreadData->StartThread = BLUE_THREAD_DOING;
	aDeviceType = (BLUE_DEVICE_TYPE)pThreadData->blue_device_type;
	aIndex = pThreadData->nIndex;

	pctrlMSComm = pThreadData->pctrlMSComm;
	if (!pctrlMSComm) 
	{
		pThreadData->StartThread = BLUE_THREAD_STOP;
		pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
		pThreadData->pDlg->DeletePCB(aDeviceType,aIndex);
		return -1;		//如果线程参数位空, 直接退出
	}

	if (!IsExistFile(pThreadData->Filename))
	{
		pThreadData->StartThread = BLUE_THREAD_STOP;
		pThreadData->pDlg->DBG_print("[%d]文件不存在, 请重新设定软件路径",__LINE__);
		pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
		pThreadData->pDlg->DeletePCB(aDeviceType,aIndex);
		return -1;
	}
	pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("停止");
	res_openfile = MyFile1.Open(pThreadData->Filename,CFile::modeRead|CFile::shareDenyNone);
	if (!res_openfile)
	{
		pThreadData->StartThread = BLUE_THREAD_STOP;
		pThreadData->pDlg->DBG_print("[%d]文件打开失败",__LINE__);
		pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
		pThreadData->pDlg->DeletePCB(aDeviceType,aIndex);
		return -1;
	}
	//获得文件大小
	Length = MyFile1.GetLength();
	numParts = Length/512;	//文件按512分割块数
	Partsremain = Length%512;	//文件分割之后的尾数

	

	for(loop=0;loop<numParts;loop++)
	{
		if (pThreadData->StartThread == false) 
		{// 检查是否有停止指令
			pThreadData->StartThread = BLUE_THREAD_STOP;
			MyFile1.Close();
			ByteArray_512.RemoveAll();
			pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
			pThreadData->pDlg->DeletePCB(aDeviceType,aIndex);
			return 0;
		}

		MyFile1.Seek(loop*512,CFile::begin);
		MyFile1.Read(ByteBuf_512,512);
		ByteArray_512.SetSize(1 * 512);
		for (int i= 0;i <  512; i++)
			ByteArray_512.SetAt(i, ByteBuf_512[i]); //把buf的1k数据转化为十六进制到array中,用于串口发送
		pctrlMSComm->SetOutput((COleVariant) ByteArray_512); //发送
		Sleep (2);					//等待接收端接收
		::SendMessage(pThreadData->pDlg->m_hWnd,WM_UPDATEPOS,pThreadData->blue_device_type<<16|pThreadData->nIndex,loop*100/numParts);
		if(!(loop&0x7f)) pThreadData->pDlg->DBG_print("线路 %d.%d下载中%d/%d",aDeviceType+1,aIndex+1,loop,numParts);
	}
	if (Partsremain>0)
	{
		MyFile1.Seek(loop*512,CFile::begin);
		MyFile1.Read(ByteBuf_512,Partsremain);
		ByteArray_512.SetSize(1 * Partsremain);
		for (int i= 0; i < 1 * Partsremain; i++)
			ByteArray_512.SetAt(i, ByteBuf_512[i]); //把buf的1k数据转化为十六进制到array中,用于串口发送
		pctrlMSComm->SetOutput((COleVariant) ByteArray_512); //发送
	}
	Sleep(1000);							//等待接收端写30M数据到文件中
	::SendMessage(pThreadData->pDlg->m_hWnd,WM_UPDATEPOS,pThreadData->blue_device_type<<16|pThreadData->nIndex,100);
	//任务结束,  清理现场
	MyFile1.Close();
	ByteArray_512.RemoveAll();

	//pThreadData->pDlg->DBG_print("线路%d, %d 下载完成!!!",aDeviceType+1,aIndex+1);
	pThreadData->pDlg->calcTImeWhenFinished(aDeviceType,aIndex);
	pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
	pThreadData->pDlg->DeletePCB(aDeviceType,aIndex);
	pThreadData->StartThread = BLUE_THREAD_STOP;
	return 0;
}



bool CBlueFlashToolDlg::SendFileToComPort(BLUE_DEVICE_TYPE earOrUsb, int index)
{
	return false;
}

#if 0//xiemeng_othd


void Funcfromnet(void)

{
	FILE *			pSENDFILE = _wfopen(m_edit_chosefile, _T("rb")); //以二进制打开待发送文件的的文件指针

	fseek(pSENDFILE, 0, SEEK_END);
	int 			len = ftell(pSENDFILE); 

	fseek(pSENDFILE, 0, SEEK_SET);
	if (len > (30 * 1024 * 1024)) //如果待发送文件大于30M
	{
		int 			bigloop = len / (30 * 1024 * 1024); //一共有bigloop个30M
		int 			bigremain = len % (30 * 1024 * 1024); //发送bigloop个30M之后还bigremain个字节

		for (int i = 0; i < bigloop; i++) //每次循环发送30M,循环结束代表发送完成了bigloop次30M文件
		{
			BYTE			ByteBuf_1K[1 * 1024];	//每次读取文件buf为1k
			CByteArray		ByteArray_1K;			//每次发送文件array为1k

			ByteArray_1K.SetSize(1 * 1024);
			for (int j = 0; j < (30 * 1024); j++) //这个循环实现发送30M文件
			{
				　　fread (ByteBuf_1K, 1 * 1024, 1, pSENDFILE); //从文件读取1k数据到buf中
				　　for (int k	= 0; k < 1 * 1024; k++) 　　ByteArray_1K.SetAt(k, ByteBuf_1K[k]); //把buf的1k数据转化为十六进制到array中,用于串口发送
				　　m_mscomm.put_Output((COleVariant) ByteArray_1K); //发送
				　　Sleep (2);					//等待接收端接收
			}
			Sleep(2000);							//等待接收端写30M数据到文件中
		}

		/*发送bigloop次30M之后，如果剩余数据大于1K*/
		if (bigremain > 1 * 1024)
		{
			int 			smallloop = bigremain / (1 * 1024); //需要发送loop次
			int 			smallremain = bigremain % (1 * 1024); ///发送loop次之后还剩remain个字节
			BYTE			ByteBuf_1K[1 * 1024];	//这个buf用来存从待发送文件独读出来的数据
			CByteArray		ByteArray_1K;			//这个array用来存待发送文件十六进制数据

			ByteArray_1K.SetSize(1 * 1024); 		//一次发送1k数据
			for (int i = 0; i < smallloop; i++)
			{
				fread(ByteBuf_1K, 1 * 1024, 1, pSENDFILE); //把待发送文件的第loop个4k以二进制读取在buf里
				for (int k = 0; k < (1 * 1024); k++)
					ByteArray_1K.SetAt(k, ByteBuf_1K[k]); //把buf里的字符以十六进制存在array里
				m_mscomm.put_Output((COleVariant) ByteArray_1K); //发送
				Sleep(2);							//等待接收方写文件所需时间，否则会有乱码;这个时间过大会阻塞，过小会丢包
			}

			/*发送剩余的smallremain个字节*/
			BYTE *			bufremain;

			bufremain			= new BYTE[smallremain]; //new1个数组，发送剩余数据
			CByteArray		arrayremain;			//装剩余数据的十六进制

			arrayremain.SetSize(smallremain);
			fread(bufremain, smallremain, 1, pSENDFILE); //读取剩余数据
			for (int l = 0; l < smallremain; l++) //转换数据为CByteArray类型
				arrayremain.SetAt(l, bufremain[l]);
			m_mscomm.put_Output((COleVariant) arrayremain); //发送剩余数据
			Sleep(200); 							//短暂休眠
			delete bufremain;						//回收bufremain
			fclose(pSENDFILE);						//关闭文件指针
		}

		/*发送bigloop次30M之后，如果剩余数据小于1K*/
		else 
		{
			BYTE *			buf;

			buf 				= new BYTE[bigremain]; //new一个buf来存从文件指针读取的数据
			fread(buf, bigremain, 1, pSENDFILE);	//读取待发送文件数据，存在buf里面
			CByteArray		array;					//用来保存发送数据的十六进制形式

			array.SetSize(bigremain);				//给array设置大小,这个大小为待发送文件的字节数
			for (int m = 0; m < bigremain; m++)
				array.SetAt(m, buf[m]); //数据转十六进制
			m_mscomm.put_Output((COleVariant) array); //发送数据
			Sleep(200); 							//短暂睡眠，可以不取
			delete buf; 							//回收
			array.RemoveAll();						//关闭文件指针
			fclose(pSENDFILE);
		}
	}
}


#endif
LRESULT CBlueFlashToolDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_UPDATEPOS:
		{
 			int colorstep = (255/100)*lParam;
 			int device_type = HIWORD(wParam);
 			int device_index = LOWORD(wParam);
 			myctrlProcess[device_type][device_index].SetPos(lParam);
 			myctrlProcess[device_type][device_index].SendMessage(PBM_SETBARCOLOR, 0, RGB(0, colorstep, 255-colorstep));//背景色为蓝色
		}
		break;
	case WM_DEVICECHANGE:
		{
			DEV_BROADCAST_HDR *pdevices_info = (DEV_BROADCAST_HDR *)lParam;
			if (pdevices_info)
			{
				if (pdevices_info->dbch_devicetype == 3)
				{//UART类型设备
					switch (wParam)
					{
						case DBT_DEVICEARRIVAL:
							DBG_print("新串口接入");
							break;
						case DBT_DEVICEREMOVECOMPLETE:
							DBG_print("串口线拔出");
					}
					UartDeviceChange();
				}
			}
		}
		break;
	case WM_COMMAND:
		{
			int currID;
			int device_type;
			int device_index;
			CString strtmsg;
			CString strButonText;
			DWORD itemdataCombo;
			switch (HIWORD(wParam))
			{
			case CBN_SELCHANGE:
				{
					currID = LOWORD(wParam);
					if (currID >= IDC_UART_CONFIG0 && currID <= IDC_UART_CONFIG99)
					{
						CComboBox *pCombobox = (CComboBox *)GetDlgItem(currID);
						itemdataCombo = pCombobox->GetItemData(pCombobox->GetCurSel());
						device_type = itemdataCombo>>16;
						device_index = HIBYTE(LOWORD(itemdataCombo));
						g_AppMainData.ary_myComPort[device_type][device_index] = LOBYTE(LOWORD(itemdataCombo));;
						if (g_AppMainData.ary_myComPort[device_type][device_index] == 1)
						{
							DBG_print("COM1不可用!");
							g_AppMainData.ary_myComPort[device_type][device_index] = 0;
						}
					}
					UpdateGroupsCaptions();
				}
				break;
			case BN_CLICKED:
				{
					currID = LOWORD(wParam);
					if (currID >= IDC_BUTTON_START0 && currID <= IDC_BUTTON_START99)
					{
						device_type 		= (currID - IDC_BUTTON_START0) / MAX_TOPWELL_DEVICE_NUM;
						device_index		= (currID - IDC_BUTTON_START0) % MAX_TOPWELL_DEVICE_NUM;
						if (ifUartEnable[device_type][device_index] == false)
						{
							if (!OpenComport(device_type, device_index))
								return 0;
						}
						#ifdef __TOPWELL_EDIT_SN_ENABLE__
						if (SaveBin(device_type,device_index) == false)
						{
							DBG_print("生成文件失败");
							return 0;
						}
						#endif
						GetDlgItem(currID)->GetWindowText(strButonText);
						if (strButonText == "开始")
						{
						}
						else if (strButonText == "停止")
						{
							DWORD threadExitcode;
								//TerminateThread(m_hThread[aDeviceType][aIndex], 0);
							myThreadData[device_type][device_index].StartThread = BLUE_THREAD_STOP;
							GetExitCodeThread(myThreadData[device_type][device_index].m_hThread, &threadExitcode); 
							if (threadExitcode != STILL_ACTIVE) 
								GetDlgItem(currID)->SetWindowText("开始");
						}
					}
				}
				break;
			}
		}
		break;
	}
	return CDialog::WindowProc(message, wParam, lParam);
}

void CBlueFlashToolDlg::OnBnClickedStartAll()
{
	int loop1,loop2;
	CString strtmsg;
	for (loop1 = 0; loop1 < BLUE_TYPE_MAX; loop1++)
	{
		for (loop2 = 0; loop2 < MAX_TOPWELL_DEVICE_NUM; loop2++)
		{
			myThreadData[loop1][loop2].pDlg = this;
			myThreadData[loop1][loop2].blue_device_type = (BYTE)loop1;
			myThreadData[loop1][loop2].nIndex = loop2;
			myThreadData[loop1][loop2].pctrlMSComm = &mycom[loop1][loop2];
			myStaticSn[loop1][loop2].GetWindowText(strtmsg);
			myThreadData[loop1][loop2].Filename = mystrAppcurrDir+"Bins\\ear\\"+strtmsg;

			if (g_AppMainData.ary_myComPort[loop1][loop2] >2)
			{
				myThreadData[loop1][loop2].StartThread = BLUE_THREAD_READY;
				myctrlStartButton[loop1][loop2].SetWindowText("停止");
			//myThreadData[loop1][loop2].m_hThread = AfxBeginThread(BlueFlashThreadProc, &myThreadData[loop1][loop2]);
			}
		}
	}

	// TODO: Add your control notification handler code here
}

// 拔出或者插入UART线, 更新列表信息
void CBlueFlashToolDlg::UartDeviceChange(void)
{
	int loop1,loop2,loop3;
	DWORD itemdataComPortList;
	int			sumPort = 0;
	CString strinfo;
	
	QuerySerialPortStatusEx(myAryExistPort,myAryNoneOpenedPort,myAryAlreadyOpenedPort,myAryNotExistPort,1,254);

	for (loop1 = 0;loop1< myAryExistPort.GetSize();loop1++)
	{
		strinfo.Format("%d",myAryExistPort.GetAt(loop1));
		mylistDebugInfo.AddString(strinfo);
	}

	for (loop1 = 0;loop1<BLUE_TYPE_MAX; loop1++)
	{
		for (loop2 = 0;loop2 <MAX_TOPWELL_DEVICE_NUM;loop2++)
		{
			myctrlComboComPort[loop1][loop2].ResetContent();
			myctrlComboComPort[loop1][loop2].AddString("不下载");
			itemdataComPortList=0;
			itemdataComPortList = loop1<<16|loop2<<8;
			myctrlComboComPort[loop1][loop2].SetItemData(0, itemdataComPortList);
			if (g_AppMainData.ary_myComPort[loop1][loop2] <2)
				myctrlComboComPort[loop1][loop2].SetCurSel(0);
			for (loop3 = 0; loop3 < myAryExistPort.GetSize(); loop3++)
			{
				CString strComName;
				strComName.Format("COM%d",myAryExistPort.GetAt(loop3));
				int add_index = myctrlComboComPort[loop1][loop2].AddString(strComName);
				itemdataComPortList=0;
				itemdataComPortList = loop1<<16|loop2<<8|myAryExistPort.GetAt(loop3);
				myctrlComboComPort[loop1][loop2].SetItemData(add_index,itemdataComPortList);
				if (myAryExistPort.GetAt(loop3) == g_AppMainData.ary_myComPort[loop1][loop2])
				{
					myctrlComboComPort[loop1][loop2].SetCurSel(add_index);
				}
			}
		}
	}
}

#ifdef __TOPWELL_EDIT_SN_ENABLE__
bool CBlueFlashToolDlg::LoadBin(int blueDeviceType)
{
	CFile MyFile1;
	int Length;
	BOOL result_openfile;
	int sumPort = 0;
	DBG_print("正在加载bin文件");


	if (blueDeviceType == BLUE_TYPE_EAR)
	{
		if(g_AppMainData.FilePathEar == "")
		{
			DBG_print("耳机软件为空");
			return false;
		}
		result_openfile = MyFile1.Open(g_AppMainData.FilePathEar, CFile::modeRead|CFile::typeBinary);
	}
	else
	{
		if(g_AppMainData.FilePathEar == "")
		{
			DBG_print("Dongle软件为空");
			return false;
		}
		result_openfile = MyFile1.Open(g_AppMainData.FilePathUsb, CFile::modeRead|CFile::typeBinary);
	}

	if (result_openfile == FALSE)
	{
		MyFile1.Close();
		DBG_print("Bin文件读写错误");
		return false;
	}
	if (blueDeviceType == BLUE_TYPE_EAR)
	{
		myLenForFile = MyFile1.GetLength();
		memset(mybufferForFile,0,1024*1024*2);
		MyFile1.Seek(0,CFile::begin);
		MyFile1.Read(mybufferForFile,myLenForFile);
		MyFile1.Close();
	}
	else
	{
		myLenForFileUSB = MyFile1.GetLength();
		memset(mybufferForFileUSB,0,1024*1024*2);
		MyFile1.Seek(0,CFile::begin);
		MyFile1.Read(mybufferForFileUSB,myLenForFileUSB);
		MyFile1.Close();
	}
	return true;
}
bool CBlueFlashToolDlg::SaveBin(int blueDeviceType)
{
	char *pSearchKey;
	int loop=0;
	char buf_SN[4];
	CFile MyFile1;
	CString WFileName;
	BOOL result_openfile;

	int SN_readwrite = g_AppMainData.SN_cur;
	DBG_print("准备写入SN号");
	pSN_write = (topwell_SN_write_struct *)strstr((char *)mybufferForFile,"TOPWELL2021");
	if ( pSearchKey == NULL)
	{
		DBG_print("写入SN号失败");
		return false;
	}
	for (loop = 0; loop < MAX_TOPWELL_DEVICE_NUM; loop++)
	{
		if (mySN_readwrite[loop] >0) SN_readwrite;
		memset(buf_SN,0,4);
		sprintf(buf_SN,"%c%4x",g_AppMainData.SN_head,g_AppMainData.SN_cur);
		
		memcpy(pSN_write->optek_link_group,buf_SN,3);
		if (blueDeviceType == BLUE_TYPE_EAR)
			WFileName.Format("Ear%s%s.bin",GetCurrPath(),buf_SN);
		else
			WFileName.Format("Dongle%s%s.bin",GetCurrPath(),buf_SN);
		DBG_print("正在生成新SN号软件..........");
		result_openfile = MyFile1.Open(WFileName, CFile::modeCreate|CFile::modeWrite);
		MyFile1.Write(mybufferForFile, myLenForFile);
		MyFile1.Close();
	}	
}
bool CBlueFlashToolDlg::SaveBin(int blueDeviceType,int index)
{
	char buf_SN[4];
	CFile MyFile1;
	CString WFileName,strSn;
	BOOL result_openfile;

	int SN_readwrite = g_AppMainData.SN_cur;
	DBG_print("准备写入SN号");
	pSN_write = (topwell_SN_write_struct *)strstr((char *)mybufferForFile,"TOPWELL2021");

	//测试代码
	pSN_write = (topwell_SN_write_struct *)(mybufferForFile+10);

	
	if ( pSN_write == NULL)
	{
		DBG_print("写入SN号失败");
		return false;
	}

	//if (mySN_readwrite[index] >0) SN_readwrite++;
	myStaticSn[index].GetWindowText(strSn);
	memset(buf_SN,0,4);
	strncpy(buf_SN, strSn.GetBuffer(0),4);
	
	memcpy(pSN_write->optek_link_group,buf_SN,3);
	if (blueDeviceType == BLUE_TYPE_EAR)
		WFileName.Format("%sEar%04x.bin",GetCurrPath(),mySN_readwrite[index]);
	else
		WFileName.Format("%sDongle%04x.bin",GetCurrPath(),mySN_readwrite[index]);
	DBG_print("正在生成新SN号软件..........");
	result_openfile = MyFile1.Open(WFileName, CFile::modeCreate|CFile::modeWrite);
	if (result_openfile == FALSE)
	{
		DBG_print("创建文件失败..");
		return false;
	}
	MyFile1.Write(mybufferForFile, myLenForFile);
	MyFile1.Close();
	
}
#endif

void CBlueFlashToolDlg::OnBnClickedStopAll()
{
	int loop1,loop2;
	CString strtmsg;
	DWORD threadExitcode;
	mylistDebugInfo.ResetContent();
	for (loop1 = 0; loop1 < BLUE_TYPE_MAX; loop1++)
	{
		for (loop2 = 0; loop2 < MAX_TOPWELL_DEVICE_NUM; loop2++)
		{
			myThreadData[loop1][loop2].StartThread = BLUE_THREAD_STOP;
			GetExitCodeThread(myThreadData[loop1][loop2].m_hThread, &threadExitcode); 
			if (threadExitcode != STILL_ACTIVE) 
				myctrlStartButton[loop1][loop2].SetWindowText("开始");
		}
	}
}

void CBlueFlashToolDlg::DeletePCB(int device_type, int index)
{
	myctrlPcbState[device_type][index].SetBitmap(myBitmapWait);
}

void CBlueFlashToolDlg::calcTImeWhenFinished(int device_type, int index)
{
	char fileid[6];
	char *pchar;
	int loop;
	CString strOfFilename;
	memset(fileid,0,6);
	DBG_print("线路 %d  %d 下载完成, 耗时 %d 秒",device_type+1,index+1,
		(GetTickCount() -mytickcount[device_type][index] )/1000);
	myStaticSn[device_type][index].GetWindowText(strOfFilename);
	pchar = strOfFilename.GetBuffer(0);
	strncpy(fileid,pchar+3,4);
	for (loop = 0; loop < myAryFlashFail.GetSize(); loop++)
	{
		WORD thefileid = myAryFlashFail.GetAt(loop);
		if (atoi(fileid) == thefileid)
		{
			myAryFlashFail.RemoveAt(loop);
			myAryFlashSuc.Add(thefileid);
		}
	}
}