mcuprogrammersettingsdlg.cpp

MCU Production Programmer

// MCUProgrammerSettingsDlg.cpp : implementation file
//

#include "stdafx.h"
#include "MCUProgrammer.h"
#include "MCUProgrammerSettingsDlg.h"
#include "SiUtilExports.h"

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

/////////////////////////////////////////////////////////////////////////////
// CMCUProgrammerSettingsDlg dialog


CMCUProgrammerSettingsDlg::CMCUProgrammerSettingsDlg(PPROGRAM_SETTINGS pProgramSettings, CWnd* pParent /*=NULL*/)
	: CDialog(CMCUProgrammerSettingsDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CMCUProgrammerSettingsDlg)
	m_EraseCodeSpace = FALSE;
	m_SerializeParts = FALSE;
	m_HexFile = _T("");
	m_MaxSerialNumber = 0;
	m_NumberPartsInRange = 0;
	m_SerialNumberCodeLocation = _T("0000");
	m_SerialNumberIncrement = 1;
	m_StartingSerialNumber = 0;
	m_LogToFile = FALSE;
	m_LogFile = _T("MCUProgramLog.txt");
	m_AppendToLog = FALSE;
	//}}AFX_DATA_INIT

	m_pProgramSettings = pProgramSettings;
}


void CMCUProgrammerSettingsDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CMCUProgrammerSettingsDlg)
	DDX_Control(pDX, IDC_COMBO_SERIALNUMBERSIZE, m_ComboSerialNumberSize);
	DDX_Control(pDX, IDC_COMBO_PARTNUMBER, m_ComboPartNumber);
	DDX_Control(pDX, IDC_COMBO_DEBUGADAPTER, m_ComboDebugAdapter);
	DDX_Check(pDX, IDC_CHECK_ERASECODESPACE, m_EraseCodeSpace);
	DDX_Check(pDX, IDC_CHECK_SERIALIZEPARTS, m_SerializeParts);
	DDX_Text(pDX, IDC_EDIT_HEXFILE, m_HexFile);
	DDX_Text(pDX, IDC_EDIT_MAXSERIALNUMBER, m_MaxSerialNumber);
	DDX_Text(pDX, IDC_EDIT_NUMBERPARTSINRANGE, m_NumberPartsInRange);
	DDX_Text(pDX, IDC_EDIT_SERIALNUMBERCODELOCATION, m_SerialNumberCodeLocation);
	DDV_MaxChars(pDX, m_SerialNumberCodeLocation, 4);
	DDX_Text(pDX, IDC_EDIT_SERIALNUMBERINCREMENT, m_SerialNumberIncrement);
	DDV_MinMaxUInt(pDX, m_SerialNumberIncrement, 0, 4228250625);
	DDX_Text(pDX, IDC_EDIT_STARTINGSERIALNUMBER, m_StartingSerialNumber);
	DDX_Check(pDX, IDC_CHECK_LOGTOFILE, m_LogToFile);
	DDX_Text(pDX, IDC_EDIT_LOGFILE, m_LogFile);
	DDX_Check(pDX, IDC_CHECK_APPENDLOGFILE, m_AppendToLog);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CMCUProgrammerSettingsDlg, CDialog)
	//{{AFX_MSG_MAP(CMCUProgrammerSettingsDlg)
	ON_EN_CHANGE(IDC_EDIT_SERIALNUMBERINCREMENT, OnChangeSerial)
	ON_BN_CLICKED(IDC_BUTTON_BROWSE, OnButtonBrowse)
	ON_BN_CLICKED(IDC_CHECK_LOGTOFILE, OnCheckLogtofile)
	ON_BN_CLICKED(IDC_BUTTON_LOADSETTINGS, OnButtonLoadsettings)
	ON_CBN_SELCHANGE(IDC_COMBO_SERIALNUMBERSIZE, OnChangeSerial)
	ON_EN_CHANGE(IDC_EDIT_STARTINGSERIALNUMBER, OnChangeSerial)
	ON_EN_CHANGE(IDC_EDIT_SERIALNUMBERCODELOCATION, OnChangeSerial)
	ON_BN_CLICKED(IDC_BUTTON_SAVESETTINGS, OnButtonSavesettings)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMCUProgrammerSettingsDlg message handlers

BOOL CMCUProgrammerSettingsDlg::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	CString deviceSerial;
	DWORD i = 0;
	const char *pString;

	// List all EC and ToolStick debug adapters found
	if (SUCCEEDED(USBDebugDevices(&m_ConnectedDevices)))
	{
		for (i = 0; i < m_ConnectedDevices; i++)
		{
			pString = deviceSerial.GetBuffer(1);

			if (pString && SUCCEEDED(GetUSBDeviceSN(i, &pString)))
			{
				m_ComboDebugAdapter.AddString(pString);
			}

			deviceSerial.ReleaseBuffer();
			pString = NULL;
		}
	}

	// Next list COM ports for a serial debug adapter
	for (i = 1; i <= 255; i++)
	{
		deviceSerial.Format("COM%d", i);
		m_ComboDebugAdapter.AddString(deviceSerial);
	}

	// Initialize the selection to the serial if it is in the list,
	// otherwise the first item
	m_ComboDebugAdapter.SelectString(-1, m_pProgramSettings->debugAdapter);

	if (m_ComboDebugAdapter.GetCurSel() < 0)
	{
		m_ComboDebugAdapter.SetCurSel(0);
	}
	
	// Initialize all other settings from the program settings structure
	m_ComboPartNumber.SelectString(-1, m_pProgramSettings->partNumber);
	m_HexFile = m_pProgramSettings->hexFile;
	m_SerializeParts = m_pProgramSettings->serializeParts;
	m_EraseCodeSpace = m_pProgramSettings->eraseCodeSpace;
	m_ComboSerialNumberSize.SetCurSel(m_pProgramSettings->serialNumberSize - 1);
	m_StartingSerialNumber = m_pProgramSettings->startingSerialNumber;
	m_SerialNumberIncrement = m_pProgramSettings->serialNumberIncrement;
	m_SerialNumberCodeLocation.Format("%04X", m_pProgramSettings->serialNumberCodeLocation);
	m_LogToFile = m_pProgramSettings->logToFile;
	m_AppendToLog = m_pProgramSettings->appendToLog;

	// If we are logging to file, close it for now in case settings change
	if (m_LogToFile && m_pProgramSettings->logFile.m_hFile != (UINT)INVALID_HANDLE_VALUE)
	{
		m_pProgramSettings->logFile.Close();
	}
	
	// Only enable the append if we are logging, if not do not allow it
	// as a selection
	if (m_LogToFile)
	{
		GetDlgItem(IDC_CHECK_APPENDLOGFILE)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_CHECK_APPENDLOGFILE)->EnableWindow(FALSE);
	}

	UpdateData(FALSE);

	// Update the serial ranges
	OnChangeSerial();

	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CMCUProgrammerSettingsDlg::OnOK() 
{
	UpdateData(TRUE);

	// Check that valid settings are selected
	if (m_ComboPartNumber.GetCurSel() == -1)
	{
		MessageBox("Please select a part number", "Error", MB_OK | MB_ICONEXCLAMATION);
	}
	else if (m_HexFile.GetLength() == 0)
	{
		MessageBox("Please enter a valid file name", "Error", MB_OK | MB_ICONEXCLAMATION);
	}
	else if (m_StartingSerialNumber > m_MaxSerialNumber)
	{
		MessageBox("Please enter starting serial number that is in range", "Error", MB_OK | MB_ICONEXCLAMATION);
	}
	else
	{
		// If there are no errors, then set the program settings structure to contain
		// all the program settings, and close the dialog with an OK
		m_ComboPartNumber.GetWindowText(m_pProgramSettings->partNumber);
		m_ComboDebugAdapter.GetWindowText(m_pProgramSettings->debugAdapter);
		m_pProgramSettings->debugAdapterType = ((DWORD)m_ComboDebugAdapter.GetCurSel() >= m_ConnectedDevices) ? SERIAL_ADAPTER : USB_ADAPTER;
		m_pProgramSettings->hexFile = m_HexFile;
		m_pProgramSettings->serializeParts = m_SerializeParts;
		m_pProgramSettings->eraseCodeSpace = m_EraseCodeSpace;
		m_pProgramSettings->startingSerialNumber = m_StartingSerialNumber;
		m_pProgramSettings->maxSerialNumber = m_MaxSerialNumber;
		m_pProgramSettings->serialNumberIncrement = m_SerialNumberIncrement;
		m_pProgramSettings->serialNumberSize = m_ComboSerialNumberSize.GetCurSel() + 1;
		m_pProgramSettings->serialNumberCodeLocation = (WORD)strtoul(m_SerialNumberCodeLocation, NULL, 16);

		// The EC protocol is C2 or JTAG depending on the device, currently the cutoff is the C8051F300
		// for JTAG, and everything above it is C2. This is denoted by setting the #define for
		// the index of the first C2 device listed, and is named FIRST_C2_DEVICE_LISTED
		m_pProgramSettings->ecProtocol = (m_ComboPartNumber.GetCurSel() >= FIRST_C2_DEVICE_LISTED) ? EC_C2 : EC_JTAG;
		
		m_pProgramSettings->logToFile = m_LogToFile;
		m_pProgramSettings->appendToLog = m_AppendToLog;
		
		// If we are logging to file, try to open it now and set it up for logging
		if (m_LogToFile)
		{
			// Open the log file, if we are appending then simply try to open. If that fails (or
			// appending is not enabled) then just create the file. Finally, if that fails the file
			// is invalid or locked
			if (m_AppendToLog && m_pProgramSettings->logFile.Open(m_LogFile, CFile::modeWrite))
			{
				m_pProgramSettings->logFile.SeekToEnd();
				m_pProgramSettings->logFile.Write("\r\n\r\n", sizeof("\r\n\r\n") - 1);

				CDialog::OnOK();
			}
			else if (m_pProgramSettings->logFile.Open(m_LogFile, CFile::modeWrite | CFile::modeCreate))
			{
				m_pProgramSettings->logFile.SeekToBegin();

				CDialog::OnOK();
			}
			else
			{
				if (MessageBox("Could not open file for logging, do you want to continue with logging disabled?", "Error", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
				{
					m_pProgramSettings->logToFile = m_LogToFile = FALSE;

					UpdateData(TRUE);

					CDialog::OnOK();
				}
			}
		}
		else
		{
			CDialog::OnOK();
		}
	}
}

void CMCUProgrammerSettingsDlg::OnChangeSerial() 
{
	UINT i = 0;

	// This function is called when any serial settings are changed
	// and updates the information in the read only boxes

	UpdateData(TRUE);
	
	// Obtain the maximum serial number and display it
	UINT serialNumberSize = m_ComboSerialNumberSize.GetCurSel() + 1;
	
	// Reset the max serial number to 0
	m_MaxSerialNumber = 0;

	// Increase the max serial number by a factor of 256 for each byte that
	// is allocated for it ie, 1 byte is 256, 2 bytes is 256 * 256, etc.
	for (i = 0; i < serialNumberSize; i++)
	{
		m_MaxSerialNumber = (256 * (m_MaxSerialNumber + 1)) - 1;
	}

	// Determine the number of serial numbers it range if the increment is
	// not 0. If it is, then there is only 1 serial in range, the starting serial number
	if (m_SerialNumberIncrement > 0)
	{
		// Reset the parts in range
		m_NumberPartsInRange = 0;

		// If the starting serial is 0, and the size is 4 bytes with an increment of 1, then display the
		// max UINT value, otherwise the equation overflows it to 0
		// If the starting serial is less than the max serial number then equate the number of parts in range
		// If the starting serial is equal to the max serial, there is only 1 part in range and is a special
		// case since the equation will produce a 0
		if ((m_StartingSerialNumber == 0) && (m_MaxSerialNumber == 0xFFFFFFFF) && (m_SerialNumberIncrement == 1))
		{
			m_NumberPartsInRange = 0xFFFFFFFF;
		}
		else if (m_StartingSerialNumber < m_MaxSerialNumber)
		{
			m_NumberPartsInRange = ((m_MaxSerialNumber - m_StartingSerialNumber) / m_SerialNumberIncrement) + 1;
		}
		else if (m_StartingSerialNumber == m_MaxSerialNumber)
		{
			m_NumberPartsInRange = 1;
		}
	}
	else
	{
		m_NumberPartsInRange = 1;
	}

	UpdateData(FALSE);
}


void CMCUProgrammerSettingsDlg::OnButtonBrowse() 
{
	UpdateData(TRUE);

	CFileDialog fileDlg(TRUE, NULL, NULL, OFN_NOCHANGEDIR, "Hex Files (*.hex)|*.hex|All Files(*.*)|*.*||");
	
	// Browse for the Hex file
	if (fileDlg.DoModal() == IDOK)
	{
		m_HexFile = fileDlg.GetPathName();
	}

	UpdateData(FALSE);
}

void CMCUProgrammerSettingsDlg::OnCheckLogtofile() 
{
	UpdateData(TRUE);

	// Only enable the append if we are logging, if not do not allow it
	// as a selection
	if (m_LogToFile)
	{
		GetDlgItem(IDC_CHECK_APPENDLOGFILE)->EnableWindow(TRUE);
	}
	else
	{
		GetDlgItem(IDC_CHECK_APPENDLOGFILE)->EnableWindow(FALSE);
	}	
}

void CMCUProgrammerSettingsDlg::OnButtonLoadsettings() 
{
	UpdateData(TRUE);

	CFileDialog fileDlg(TRUE, "pgs", NULL, OFN_NOCHANGEDIR, "Program Settings Files (*.pgs)|*.pgs|All Files(*.*)|*.*||");
	
	// Browse for the Hex file
	if (fileDlg.DoModal() == IDOK)
	{
		SerializeSettings(fileDlg.GetPathName(), SERIALIZE_IN);
	}

	UpdateData(FALSE);

	// Configure the check boxes
	OnCheckLogtofile();

	// Update the serial settings
	OnChangeSerial();
}

void CMCUProgrammerSettingsDlg::OnButtonSavesettings() 
{
	UpdateData(TRUE);

	CFileDialog fileDlg(FALSE, "pgs", "ProgramSettings.pgs", OFN_NOCHANGEDIR, "Program Settings Files (*.pgs)|*.pgs|All Files(*.*)|*.*||");
	
	// Browse for the Hex file
	if (fileDlg.DoModal() == IDOK)
	{
		SerializeSettings(fileDlg.GetPathName(), SERIALIZE_OUT);
	}

	UpdateData(FALSE);
}

void CMCUProgrammerSettingsDlg::SerializeSettings(CString fileName, BOOL inOut)
{
	CFile iniFile;

	// Check if we are serializing in or out
	if (inOut == SERIALIZE_IN)
	{
		// Serialize in the default settings if the ini file exists
		if (iniFile.Open(fileName, CFile::modeRead))
		{
			CArchive ar(&iniFile, CArchive::load);
			Serialize(ar);
			ar.Close();
			iniFile.Close();
		}
	}
	else
	{
		// Serialize in the default settings if the ini file exists
		if (iniFile.Open(fileName, CFile::modeCreate | CFile::modeWrite))
		{
			CArchive ar(&iniFile, CArchive::store);
			Serialize(ar);
			ar.Close();
			iniFile.Close();
		}
	}
}

void CMCUProgrammerSettingsDlg::Serialize(CArchive& ar) 
{
	try
	{
		// Serialize the UART configuration in or out
		if (ar.IsStoring())
		{
			ar << m_ComboSerialNumberSize.GetCurSel();
			ar << m_ComboPartNumber.GetCurSel();
			ar << m_EraseCodeSpace;
			ar << m_SerializeParts;
			ar << m_HexFile;
			ar << m_SerialNumberCodeLocation;
			ar << m_SerialNumberIncrement;
			ar << m_StartingSerialNumber;
			ar << m_LogToFile;
			ar << m_LogFile;
			ar << m_AppendToLog;
		}
		else
		{
			int tmp;

			ar >> tmp;
			m_ComboSerialNumberSize.SetCurSel(tmp);
			ar >> tmp;
			m_ComboPartNumber.SetCurSel(tmp);
			ar >> m_EraseCodeSpace;
			ar >> m_SerializeParts;
			ar >> m_HexFile;
			ar >> m_SerialNumberCodeLocation;
			ar >> m_SerialNumberIncrement;
			ar >> m_StartingSerialNumber;
			ar >> m_LogToFile;
			ar >> m_LogFile;
			ar >> m_AppendToLog;
		}
	}
	catch(...)
	{
		
	}
}