// BlueFlashToolDlg.cpp : implementation file
//

#include "stdafx.h"
#include "BlueFlashTool.h"
#include "BlueFlashToolDlg.h"
#include "SysConfig.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);
	for (int i=0;i<10;i++)
	{
		g_AppMainData.if_flash[BLUE_TYPE_EAR][i] = 0;
		g_AppMainData.if_flash[BLUE_TYPE_USB][i] = 0;
		ifUartEnable[BLUE_TYPE_USB][i] = false;
		ifUartEnable[BLUE_TYPE_EAR][i] = false;
	}
}

void CBlueFlashToolDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CBlueFlashToolDlg)
	DDX_Control(pDX, IDC_MSCOMM0, mycom_debug);
	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)
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];
	
	CDialog::OnInitDialog();
	QuerySerialPortStatusEx(myStrAryExistPort,myStrAryNoneOpenedPort,myStrAryAlreadyOpenedPort,myStrAryNotExistPort,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));
	for (loop1 = 0;loop1<BLUE_TYPE_MAX; loop1++)
	{
		for (loop2 = 0;loop2 <MAX_TOPWELL_DEVICE_NUM;loop2++)
		{
			rect_pcb[loop1][loop2].left = 10+300*loop1;
			rect_comport[loop1][loop2].left = 30+300*loop1;
			rect_process_bar[loop1][loop2].left = 110+300*loop1;
			rect_start_button[loop1][loop2].left = 230+300*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_pcb[loop1][loop2].top = 10+25*loop2;
			rect_comport[loop1][loop2].top = 10+25*loop2;
			rect_process_bar[loop1][loop2].top = 10+25*loop2;
			rect_start_button[loop1][loop2].top = 10+25*loop2;

			rect_pcb[loop1][loop2].bottom= rect_pcb[loop1][loop2].top+20;
			rect_comport[loop1][loop2].bottom = rect_comport[loop1][loop2].top+20;
			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;

			//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);
			myctrlComboComPort[loop1][loop2].AddString("不下载");
			for (loop3 = 0; loop3 < myStrAryNoneOpenedPort.GetSize(); loop3++)
				myctrlComboComPort[loop1][loop2].AddString(myStrAryNoneOpenedPort.GetAt(loop3));
			myctrlComboComPort[loop1][loop2].SetCurSel(0);
			
			// 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_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
			   rect_start_button[loop1][loop2], this, IDC_BUTTON_START0+loop1*MAX_TOPWELL_DEVICE_NUM+loop2);


		}
	}

	
	// TODO: Add extra initialization here
// 	for (loop =0;loop<10;loop++)
// 	{
// 		pcheckButton[BLUE_TYPE_EAR][loop] = (CButton *)GetDlgItem(IDC_CHECK_EAR1+loop);
// 		pcheckButton[BLUE_TYPE_USB][loop] = (CButton *)GetDlgItem(IDC_CHECK_USB1+loop);
// 		myctrlStartButton[BLUE_TYPE_EAR][loop] = (CButton *)GetDlgItem(IDC_BUTTON_START+loop);
// 		myctrlStartButton[BLUE_TYPE_EAR][loop]->EnableWindow(FALSE);
// 		myctrlStartButton[BLUE_TYPE_USB][loop] = (CButton *)GetDlgItem(IDC_BUTTON_START_USB1+loop);
// 		myctrlStartButton[BLUE_TYPE_USB][loop]->EnableWindow(FALSE);
// 		myctrlProcess[BLUE_TYPE_EAR][loop] = (CProgressCtrl *)GetDlgItem(IDC_PROGRESS_FLASH+loop);
// 		myctrlProcess[BLUE_TYPE_USB][loop] = (CProgressCtrl *)GetDlgItem(IDC_PROGRESS_USB1+loop);
// 		pStaticSn[loop] = (CStatic *)GetDlgItem(IDC_STATIC_GROUP1+loop);
// 		myctrlPcbState[BLUE_TYPE_EAR][loop] = (CStatic *)GetDlgItem(IDC_PCB_STATE1+loop);
// 		myctrlPcbState[BLUE_TYPE_USB][loop] = (CStatic *)GetDlgItem(IDC_PCB_STATE11+loop);
// 	}
	pctrlMSComm[BLUE_TYPE_EAR][0]=&mycom01;
	pctrlMSComm[BLUE_TYPE_EAR][1]=&mycom02;
	pctrlMSComm[BLUE_TYPE_EAR][2]=&mycom03;
	pctrlMSComm[BLUE_TYPE_EAR][3]=&mycom04;
	pctrlMSComm[BLUE_TYPE_EAR][4]=&mycom05;
	pctrlMSComm[BLUE_TYPE_EAR][5]=&mycom06;
	pctrlMSComm[BLUE_TYPE_EAR][6]=&mycom07;
	pctrlMSComm[BLUE_TYPE_EAR][7]=&mycom08;
	pctrlMSComm[BLUE_TYPE_EAR][8]=&mycom09;
	pctrlMSComm[BLUE_TYPE_EAR][9]=&mycom10;
	pctrlMSComm[BLUE_TYPE_USB][0]=&mycom11;
	pctrlMSComm[BLUE_TYPE_USB][1]=&mycom12;
	pctrlMSComm[BLUE_TYPE_USB][2]=&mycom13;
	pctrlMSComm[BLUE_TYPE_USB][3]=&mycom14;
	pctrlMSComm[BLUE_TYPE_USB][4]=&mycom15;
	pctrlMSComm[BLUE_TYPE_USB][5]=&mycom16;
	pctrlMSComm[BLUE_TYPE_USB][6]=&mycom17;
	pctrlMSComm[BLUE_TYPE_USB][7]=&mycom18;
	pctrlMSComm[BLUE_TYPE_USB][8]=&mycom19;
	pctrlMSComm[BLUE_TYPE_USB][9]=&mycom20;


	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.myStrAryExistPort = &myStrAryExistPort;
	dlg.myStrAryNoneOpenedPort = &myStrAryNoneOpenedPort;
	dlg.myStrAryAlreadyOpenedPort = &myStrAryAlreadyOpenedPort;
	dlg.myStrAryNotExistPort= &myStrAryNotExistPort;
	dlg.DoModal();
	UpdateGroupsCaptions();

}

void CBlueFlashToolDlg::UpdateGroupsCaptions()
{
	CString 		strCaptionStatics;
	int 			loop = 0;
	int 			SN_readwrite = g_AppMainData.SN_cur;
	char			sum_ear, sum_usb;
	CButton *		pbutton;

	for (loop = 0; loop < 10; loop++)
	{
		if (g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][loop] < 2
			|| ifUartEnable[BLUE_TYPE_EAR][loop] == false)
		{
			g_AppMainData.if_flash[BLUE_TYPE_EAR][loop] = 0;
			//pcheckButton[BLUE_TYPE_EAR][loop]->SetCheck(0);
			//pcheckButton[BLUE_TYPE_EAR][loop]->EnableWindow(FALSE);
		}
		else
		{
			//pcheckButton[BLUE_TYPE_EAR][loop]->SetCheck(g_AppMainData.if_flash[BLUE_TYPE_EAR][loop]);
			//pcheckButton[BLUE_TYPE_EAR][loop]->EnableWindow(TRUE);
		}
		if (g_AppMainData.ary_myComPort[BLUE_TYPE_USB][loop] < 2
			|| ifUartEnable[BLUE_TYPE_USB][loop] == false)
		{
			g_AppMainData.if_flash[BLUE_TYPE_USB][loop] = 0;
			//pcheckButton[BLUE_TYPE_USB][loop]->SetCheck(0);
			//pcheckButton[BLUE_TYPE_USB][loop]->EnableWindow(FALSE);
		}
		else
		{
			//pcheckButton[BLUE_TYPE_USB][loop]->SetCheck(g_AppMainData.if_flash[BLUE_TYPE_USB][loop]);
			//pcheckButton[BLUE_TYPE_USB][loop]->EnableWindow(TRUE);
		}
		if (g_AppMainData.if_flash[BLUE_TYPE_EAR][loop] +g_AppMainData.if_flash[BLUE_TYPE_USB][loop] > 0)
		{
			pStaticSn[loop]->EnableWindow(TRUE);
			mySN_readwrite[loop] = SN_readwrite++;
			strCaptionStatics.Format("SN: %s%05d", g_AppMainData.SN_head, mySN_readwrite[loop]);
			pStaticSn[loop]->SetWindowText(strCaptionStatics);
		}
		else 
		{
			//pStaticSn[loop]->EnableWindow(FALSE);
			//pStaticSn[loop]->SetWindowText("不可用");
		}
		//myctrlStartButton[BLUE_TYPE_EAR][loop]->EnableWindow((BOOL) g_AppMainData.if_flash[BLUE_TYPE_EAR][loop]);
		//myctrlStartButton[BLUE_TYPE_USB][loop]->EnableWindow((BOOL) g_AppMainData.if_flash[BLUE_TYPE_USB][loop]);
		//pcheckButton[BLUE_TYPE_EAR][loop]->SetCheck((BOOL) g_AppMainData.if_flash[BLUE_TYPE_EAR][loop]);
		//pcheckButton[BLUE_TYPE_USB][loop]->SetCheck((BOOL) g_AppMainData.if_flash[BLUE_TYPE_USB][loop]);
	}
	sum_ear 			= g_AppMainData.if_flash[BLUE_TYPE_EAR][0] + g_AppMainData.if_flash[BLUE_TYPE_EAR][1] + g_AppMainData.if_flash[BLUE_TYPE_EAR][2] + g_AppMainData.if_flash[BLUE_TYPE_EAR][3] + g_AppMainData.if_flash[BLUE_TYPE_EAR][4] + g_AppMainData.if_flash[BLUE_TYPE_EAR][5] + g_AppMainData.if_flash[BLUE_TYPE_EAR][6] + g_AppMainData.if_flash[BLUE_TYPE_EAR][7] + g_AppMainData.if_flash[BLUE_TYPE_EAR][8] + g_AppMainData.if_flash[BLUE_TYPE_EAR][9];
	sum_usb 			= g_AppMainData.if_flash[BLUE_TYPE_USB][0] + g_AppMainData.if_flash[BLUE_TYPE_USB][1] + g_AppMainData.if_flash[BLUE_TYPE_USB][2] + g_AppMainData.if_flash[BLUE_TYPE_USB][3] + g_AppMainData.if_flash[BLUE_TYPE_USB][4] + g_AppMainData.if_flash[BLUE_TYPE_USB][5] + g_AppMainData.if_flash[BLUE_TYPE_USB][6] + g_AppMainData.if_flash[BLUE_TYPE_USB][7] + g_AppMainData.if_flash[BLUE_TYPE_USB][8] + g_AppMainData.if_flash[BLUE_TYPE_USB][9];
	GetDlgItem(IDC_START_ALL)->EnableWindow(sum_ear + sum_usb > 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+20, 1 /* OnComm */, OnCommMscomm1,  VTS_I4 )  
END_EVENTSINK_MAP()


void CBlueFlashToolDlg::OnCommMscommDebug()
{
	// TODO: Add your message handler code here
}





void CBlueFlashToolDlg::OnBnClickedButtonInitComport()
{
	int loop = 0;
	for (loop = 0; loop < 10; loop++)
	{
			OpenComport(BLUE_TYPE_EAR,loop);
			OpenComport(BLUE_TYPE_USB,loop);
	}
	UpdateGroupsCaptions();
}

void CBlueFlashToolDlg::OnBnClickedCheckEarUsb()
{
// 	int currentID;
// 	currentID = GetFocus()->GetDlgCtrlID();
// 	CButton *pbutton = (CButton *)GetDlgItem(currentID);
// 	BOOL ifchecked = pbutton->GetCheck();
// 	if (currentID >= IDC_CHECK_EAR1 && currentID <= IDC_CHECK_EAR10)
// 		g_AppMainData.if_flash[BLUE_TYPE_EAR][currentID -IDC_CHECK_EAR1 ] = ifchecked;
// 	else if (currentID >= IDC_CHECK_USB1 && currentID <= IDC_CHECK_USB10)
// 		g_AppMainData.if_flash[BLUE_TYPE_USB][currentID -IDC_CHECK_USB1 ] = ifchecked;
// 	UpdateGroupsCaptions();
}

void CBlueFlashToolDlg::OnBnClickedButtonStartUsbEar()
{
// 	int currentID;
// 	BLUE_DEVICE_TYPE aDeviceType;
// 	int aIndex;
//     CString strText;
// 	
// 	currentID = GetFocus()->GetDlgCtrlID();
// 	if (currentID >= IDC_BUTTON_START && currentID <= IDC_BUTTON_START_EAR10)
// 	{
// 		aDeviceType = BLUE_TYPE_EAR;
// 		aIndex = currentID - IDC_BUTTON_START;
// 		myThreadData[aDeviceType][aIndex].Filename = g_AppMainData.FilePathEar;
// 	}
// 	else if (currentID >= IDC_BUTTON_START_USB1 && currentID <= IDC_BUTTON_START_USB1)
// 	{
// 		aDeviceType = BLUE_TYPE_USB;
// 		aIndex = currentID - IDC_BUTTON_START_USB1;
// 		myThreadData[aDeviceType][aIndex].Filename = g_AppMainData.FilePathUsb;
// 	}
//     ((CWnd*)GetDlgItem(currentID))->GetWindowText(strText);
// 	if (strText == "开始")
// 	{
// 		//pThreadData = new FLASH_THREAD_DATA;
// 		myThreadData[aDeviceType][aIndex].pDlg = this;
// 		myThreadData[aDeviceType][aIndex].blue_device_type = (BYTE)aDeviceType;
// 		myThreadData[aDeviceType][aIndex].nIndex = aIndex;
// 		myThreadData[aDeviceType][aIndex].StopThread = false;
// 		myThreadData[aDeviceType][aIndex].pctrlMSComm = pctrlMSComm[aDeviceType][aIndex];
// 		myThreadData[aDeviceType][aIndex].m_hThread = AfxBeginThread(BlueFlashThreadProc, &myThreadData[aDeviceType][aIndex]);
// 	}
// 	else if (strText == "停止")
// 	{
// 		//DWORD threadExitcode;
// 		//GetExitCodeThread(m_hThread[aDeviceType][aIndex], &threadExitcode); 
// 		//if (threadExitcode == STILL_ACTIVE) TerminateThread(m_hThread[aDeviceType][aIndex], 0);
// 		myThreadData[aDeviceType][aIndex].StopThread = true;
// 	}
}


void CBlueFlashToolDlg::OnDestroy()
{
	CDialog::OnDestroy();

	g_pmainapp->SaveConfigs();

}

// 打开COM口，
bool CBlueFlashToolDlg::OpenComport(BLUE_DEVICE_TYPE earOrUsb, int index)
{
	int loop = 0;
	CString m_strSettings;
	int comopen_port;
	CMSComm *pctrlComToOpen = pctrlMSComm[BLUE_TYPE_EAR][index];

	m_strSettings.Format("%d,n,8,1", g_AppMainData.com_config.aBandrate);
	
	comopen_port =g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][index] ;
	
	DBG_print("开始打开端口 %d",comopen_port);
	if (comopen_port<2) 
	{
		DBG_print("无效端口 %d",comopen_port);
		return false;
	}
	if (QuerySingleSerialPortEx(comopen_port) != TRUE)
	{
		DBG_print("已被占用 %d",comopen_port);
		g_AppMainData.if_flash[BLUE_TYPE_EAR][loop] = 0;
		g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][loop]=0;
		ifUartEnable[earOrUsb][index] = false;
		return false;
	}
	if (pctrlComToOpen->GetPortOpen())
	{
		if (pctrlComToOpen->GetCommPort() == comopen_port)
		{
			DBG_print("该串口已打开，请勿重复打开！\r\n");
			return TRUE;
		}
	}
	//参数1表示每当串口接收缓冲区中有多于或等于1个字符时将引发一个接收数据的OnComm事件
	try
	{
		pctrlComToOpen->SetCommPort(comopen_port); //选择com1
		pctrlComToOpen->SetInputMode(1);
		pctrlComToOpen->SetInputLen(512);				//设置当前接收区数据长度为0
		pctrlComToOpen->SetOutBufferSize(512);//设置当前接收区数据长度为0
		pctrlComToOpen->SetSettings(m_strSettings);	//波特率9600，无校验，8个数据位，1个停止位
	}
	catch (CException* e)
	{
		e->ReportError(MB_ICONSTOP);
		return FALSE;
	}
	DBG_print("设置串口配置 %s",m_strSettings );

	if (!pctrlComToOpen->GetPortOpen())
	{
			try
			{
				pctrlComToOpen->SetPortOpen(TRUE); //打开串口
			}
			catch (CException* e)
			{
				e->ReportError(MB_ICONSTOP);
				return FALSE;
			}


			pctrlComToOpen->SetRThreshold(1);
			ifUartEnable[earOrUsb][index] = true;
			DBG_print("串口打开成功 %d",comopen_port);
	}
	else 
	{
		DBG_print("串口%d无法打开",comopen_port );
		g_AppMainData.if_flash[BLUE_TYPE_EAR][loop] = 0;
		g_AppMainData.ary_myComPort[BLUE_TYPE_EAR][loop]=0;
		ifUartEnable[earOrUsb][index] = false;
	}

	
	pctrlComToOpen->GetInput();					//先预读缓冲区以清除残留数据	
	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
	VARIANT 		variant_inp;
	CMSComm * apctrlMSComm;
	COleSafeArray	safearray_inp;
	LONG			len, k;
	BYTE			rxdata[512];					//设置BYTE数组 An 8-bit integerthat is not signed.
	BLUE_DEVICE_TYPE aDeviceType ;//设备类型
	int aIndex;		//设备索引
	char flash_process[4];
	memset(rxdata,0,512);
	memset(flash_process,0,4);
	if (nID >= IDC_MSCOMM1 && nID <= IDC_MSCOMM10)
	{
		aDeviceType = BLUE_TYPE_EAR;
		aIndex = nID - IDC_MSCOMM1;
	}
	if (nID >= IDC_MSCOMM11 && nID <= IDC_MSCOMM20)
	{
		aDeviceType = BLUE_TYPE_USB;
		aIndex = nID - IDC_MSCOMM11;
	}
	if (pctrlMSComm[aDeviceType][aIndex]->GetCommEvent() == 2) //事件值为2表示接收缓冲区内有字符
	{
		variant_inp 		= pctrlMSComm[aDeviceType][aIndex]->GetInput(); 	//读缓冲区
		safearray_inp		= variant_inp;			//VARIANT型变量转换为ColeSafeArray型变量
		len 				= safearray_inp.GetOneDimSize(); //得到有效数据长度
		for (k = 0; k < len; k++)
			safearray_inp.GetElement(&k, rxdata + k); //转换为BYTE型数组
		if(strstr((char *)rxdata, "Optek ROM boot") == NULL)
		{
			myctrlPcbState[aDeviceType][aIndex].SetBitmap(myBitmapWait);
		}
		else
		{
			myctrlPcbState[aDeviceType][aIndex].SetBitmap(myBitmapReady);
		}
		if (strstr((char *)rxdata,"Programming:") != NULL)
		{
			strncpy(flash_process,(char *)(rxdata+12),3);
			myctrlProcess[aDeviceType][aIndex].SetPos(atoi(flash_process));
		}
	}
}


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;
	

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

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

	

	for(loop=0;loop<numParts;loop++)
	{
		if (pThreadData->StopThread) 
		{// 检查是否有停止指令
			MyFile1.Close();
			ByteArray_512.RemoveAll();
			pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
			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*10+pThreadData->nIndex,loop*100/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*10+pThreadData->nIndex,100);
	//任务结束,  清理现场
	MyFile1.Close();
	ByteArray_512.RemoveAll();
	pThreadData->pDlg->myctrlStartButton[aDeviceType][aIndex].SetWindowText("开始");
	return 0;
}



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

#if 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)
{
	return CDialog::WindowProc(message, wParam, lParam);
}

void CBlueFlashToolDlg::OnBnClickedStartAll()
{
	// TODO: Add your control notification handler code here
}