mcuprogrammerdlg.cpp

MCU Production Programmer

				UpdateWindowProgramSettings();

				m_ProgramSettings.startingSerialNumber = tempStartingSerialNumber;
			}
			else
			{
				// Otherwise just update
				UpdateWindowProgramSettings();
			}
		}
		else
		{
			// If settings have not been programmed, or the serial doesn't
			// need a prompt for updating then just perform the update
			UpdateWindowProgramSettings();
		}

		// Settings have been programmed now if OK was pressed
		m_SettingsHaveBeenProgrammed = TRUE;

		CString startingMessage;
		CTime time;

		time = CTime::GetCurrentTime();

		// Display the settings
		startingMessage.Format("Assigned New Programming Session Settings:\r\n\r\n  Debug Adapter: %s\r\n  Part Number: %s\r\n  Hex File: %s\r\n  Erase Code Space: %s\r\n  Serialize Parts: %s\r\n  Serial Number Code Location: 0x%04X\r\n  Serial Number Size (Bytes): %u\r\n  Starting Serial: %s\r\n  Serial Increment: %s\r\n", m_ProgramSettings.debugAdapter, m_ProgramSettings.partNumber, m_ProgramSettings.hexFile, (m_ProgramSettings.eraseCodeSpace ? "Yes" : "No"), (m_ProgramSettings.serializeParts ? "Yes" : "No"), m_ProgramSettings.serialNumberCodeLocation, m_ProgramSettings.serialNumberSize, m_CurrentSerialNumberString, m_SerialNumberIncrement);
		LogMessage(&m_Log, TRUE, startingMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);

		// Display the session start time and date
		startingMessage.Format("%s - Starting New Programming Session", time.Format("%B %d %Y"));
		LogMessage(&m_Log, TRUE, startingMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);

		SetCurrentApplicationDirectory();
	}
}

void CMCUProgrammerDlg::UpdateWindowProgramSettings()
{
	// This takes all displayed settings from the program settings
	// structure and displays them in the window
	m_PartNumber = m_ProgramSettings.partNumber;
	m_DebugAdapter = m_ProgramSettings.debugAdapter;
	m_HexFile = m_ProgramSettings.hexFile;
	m_SerializeParts = m_ProgramSettings.serializeParts;
	m_EraseCodeSpace = m_ProgramSettings.eraseCodeSpace;

	// Determine if serial numbers are used, if not display an N/A in the window
	if (m_ProgramSettings.serializeParts)
	{
		m_CurrentSerialNumber = m_ProgramSettings.startingSerialNumber;
		m_CurrentSerialNumberString.Format("%u", m_ProgramSettings.startingSerialNumber);
		m_SerialNumberIncrement.Format("%u", m_ProgramSettings.serialNumberIncrement);
	}
	else
	{
		m_CurrentSerialNumber = m_ProgramSettings.startingSerialNumber;
		m_CurrentSerialNumberString = "N/A";
		m_SerialNumberIncrement = "N/A";
	}

	UpdateData(FALSE);
}

void CMCUProgrammerDlg::OnProgrammenuExit() 
{
	OnOK();
}

void CMCUProgrammerDlg::OnButtonProgramdevice()
{
	BOOL error = FALSE;
	int comPort = -1;
	CString partNumber;
	CString errorMessage;

	BeginWaitCursor();

	// If settings have been programmed then connect to the EC,
	// log error if it cannot connect (if settings have not been
	// initialized then prompt the user
	if (m_SettingsHaveBeenProgrammed)
	{
		if (m_ProgramSettings.debugAdapterType == SERIAL_ADAPTER)
		{
			// If using a serial adapter, remove the "COM" from the string, and get the
			// port number value
			comPort = atoi(m_DebugAdapter.Right(m_DebugAdapter.GetLength() - 3));

			if (FAILED(Connect(comPort, 1, m_ProgramSettings.ecProtocol, 0)))
			{
				errorMessage.Format("Can't Connect to Debug Adapter: %s", m_DebugAdapter);
				LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				error = TRUE;
			}
		}
		else if (m_ProgramSettings.debugAdapterType == USB_ADAPTER)
		{
			if (FAILED(ConnectUSB(m_DebugAdapter, m_ProgramSettings.ecProtocol, 1, 1)))
			{
				errorMessage.Format("Can't Connect to Device: %s", m_DebugAdapter);
				LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				error = TRUE;
			}
		}
	}
	else
	{
		errorMessage.Format("Settings have not been initialized");
		LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
		error = TRUE;
	}
	
	// Check that partnum matches, log error if not
	if (!error && Connected())
	{
		// Get the buffer for the part number
		const char* partNumberBuffer = partNumber.GetBuffer(1);

		if (SUCCEEDED(GetDeviceName(&partNumberBuffer)))
		{
			// Check the part number to see if it matches, if not give an error
			if (m_ProgramSettings.partNumber.Compare(partNumberBuffer) != 0)
			{
				errorMessage.Format("Connected Device (%s) does not match Specified Device (%s)", partNumberBuffer, m_ProgramSettings.partNumber);
				LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				error = TRUE;
			}
		}
		else
		{
			errorMessage.Format("Cannot obtain Connected Device Part Number");
			LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
			error = TRUE;
		}

		partNumber.ReleaseBuffer();
	}

	// Download the hex image - erase if needed, log error if it fails
	if (!error && Connected())
	{
		if (FAILED(Download(m_ProgramSettings.hexFile.GetBuffer(1), m_ProgramSettings.eraseCodeSpace, 1)))
		{
			errorMessage.Format("Error Downloading Hex File (%s)", m_ProgramSettings.hexFile);
			LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
			error = TRUE;
		}

		m_ProgramSettings.hexFile.ReleaseBuffer();
	}

	// Wait for device to finish any last minute routines after the download
	Sleep(500);

	// If we are serializing, write the serial number to the part, then check it
	// and log an error if it doesn't match or fails
	if (m_ProgramSettings.serializeParts)
	{
		BYTE serialNumber[4] = {0x00, 0x00, 0x00, 0x00};

		if (!error && Connected())
		{
			// Since a DWORD is reverse on PC memory, flip all the bytes before writing to flash
			serialNumber[0] = (m_CurrentSerialNumber & 0xFF000000) >> 24;
			serialNumber[1] = (m_CurrentSerialNumber & 0x00FF0000) >> 16;
			serialNumber[2] = (m_CurrentSerialNumber & 0x0000FF00) >> 8;
			serialNumber[3] = m_CurrentSerialNumber & 0x000000FF;

			if (FAILED(SetCodeMemory(&(serialNumber[4-m_ProgramSettings.serialNumberSize]), m_ProgramSettings.serialNumberCodeLocation, m_ProgramSettings.serialNumberSize, 1)))
			{
				errorMessage.Format("Error Setting Serial Number (%u)", m_CurrentSerialNumber);
				LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				error = TRUE;
			}
		}

		if (!error && Connected())
		{
			*(DWORD*)serialNumber = 0x00000000;

			if (SUCCEEDED(GetCodeMemory(&(serialNumber[4-m_ProgramSettings.serialNumberSize]), m_ProgramSettings.serialNumberCodeLocation, m_ProgramSettings.serialNumberSize)))
			{
				// Compare in reverse to the current serial number since bytes will be read in reverse order
				// of what we will see on the PC memory
				if ((DWORD)((serialNumber[0] << 24) + (serialNumber[1] << 16) + (serialNumber[2] << 8) + serialNumber[3]) != m_CurrentSerialNumber)
				{
					errorMessage.Format("Serial Number in Device (%u) does not match Current Serial Number (%u)", serialNumber, m_CurrentSerialNumber);
					LogMessage(&m_Log, FALSE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
					error = TRUE;
				}
			}
			else
			{
				LogMessage(&m_Log, FALSE, "Cannot obtain Serial Number from Device", m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				error = TRUE;
			}
		}
	}

	// Disconnect from EC if connected
	if (Connected() && (m_ProgramSettings.debugAdapterType == SERIAL_ADAPTER))
	{
		Disconnect(comPort);
	}
	else if (Connected() && (m_ProgramSettings.debugAdapterType == USB_ADAPTER))
	{
		DisconnectUSB();
	}

	// Log Success and increment Serial Number
	if (!error)
	{
		CString serialString;
		serialString.Format("with Serial %u", m_CurrentSerialNumber);
		errorMessage.Format("Device %sProgrammed and Verified %s", (m_ProgramSettings.eraseCodeSpace ? "Erased, " : ""), (m_ProgramSettings.serializeParts ? serialString : ""));
		LogMessage(&m_Log, TRUE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);

		// Increment serial number, log error if overflow
		if (m_ProgramSettings.serializeParts)
		{
			if (m_CurrentSerialNumber != 0xFFFFFFFF)
			{
				m_CurrentSerialNumber += m_ProgramSettings.serialNumberIncrement;
			}
			else
			{
				errorMessage.Format("WARNING: Max Serial Number reached, overflowing Current Serial Number to %u", m_ProgramSettings.startingSerialNumber);
				LogMessage(&m_Log, TRUE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				m_CurrentSerialNumber = m_ProgramSettings.startingSerialNumber;
			}

			if (m_CurrentSerialNumber > m_ProgramSettings.maxSerialNumber)
			{
				errorMessage.Format("WARNING: Max Serial Number reached, overflowing Current Serial Number to %u", m_ProgramSettings.startingSerialNumber);
				LogMessage(&m_Log, TRUE, errorMessage, m_ProgramSettings.logToFile, &m_ProgramSettings.logFile);
				m_CurrentSerialNumber = m_ProgramSettings.startingSerialNumber;
			}

			m_CurrentSerialNumberString.Format("%u", m_CurrentSerialNumber);
		}
	}

	UpdateData(FALSE);

	EndWaitCursor();
}

void CMCUProgrammerDlg::OnDestroy() 
{
	CDialog::OnDestroy();
	
	// If we were logging to file and it is a valid file, close that file now
	if (m_ProgramSettings.logToFile && (m_ProgramSettings.logFile.m_hFile != (UINT)INVALID_HANDLE_VALUE))
	{
		m_ProgramSettings.logFile.Close();
	}
}

void CMCUProgrammerDlg::HotKeyFunction(WPARAM wParam, LPARAM lParam)
{
	// All HotKeys map to this function, execute it when a hotkey combo is pressed
	OnButtonProgramdevice();
}

void CMCUProgrammerDlg::SetCurrentApplicationDirectory()
{
	char szAppPath[MAX_PATH] = "";
	CString strAppDirectory;

	GetCurrentDirectory(MAX_PATH, szAppPath);
	GetModuleFileName(0, szAppPath, sizeof(szAppPath) - 1);

	// Extract directory
	strAppDirectory = szAppPath;
	strAppDirectory = strAppDirectory.Left(strAppDirectory.ReverseFind('\\') + 1);

	// Set working directory to the current application directory for the log file
	SetCurrentDirectory(strAppDirectory);
}