gui.c

一个很好的SDL建立应用程序界面的例子

			{
				if (data == word)
				{
					track = FALSE;
					stop = i;
//printf("segment 0x%x - 0x%x\n", start, stop);
					addToSegmentList(start, stop);
				}
			}
			else
			{
				if (data != word)
				{
//printf("blank 0x%x - 0x%x\n", stop, i);
					track = TRUE;
					start = i;
				}
			}
		}

		if (track)
		{
			stop = i;
			addToSegmentList(start, stop);
		}

//printf("track %d, start 0x%x, i 0x%x\n", track, start, i);
	}

//	showSegmentList();	// for test only
}

// Interface to gpdasm

int checkGpicDasm(void)
{
	if (!gpicdasmFile)
		return 0;

	if (fgets(commandResponse, sizeof(commandResponse) - 1, gpicdasmFile))
	{
		pclose(gpicdasmFile);
		gpicdasmFile = NULL;
		return 1;
	}

	return -1;
}

void disasmCB(SDL_Event *event)
{
	bool	running = FALSE;
	int	i;
	char	commandString[64];

	if (gpicdasmFile || !programDisplayFlag)				// gpicdasm already running, or in data display
		return;

	saveFile(tempFileName);

	strcpy(commandString, gpicdasmFileName);
	strcat(commandString, " ");
	strcat(commandString, deviceType);
	strcat(commandString, " ");
	strcat(commandString, tempFileName);

	gpicdasmFile = popen(commandString, "r");		// gpicdasmFile captures gpicdasm's stdout output

	if (!gpicdasmFile)
	{
		sprintf(alertMessage, "     Can't run gpicdasm!     \n");
		errorAlert->x = 100;
		errorAlert->y = 40;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		popUpWidget(errorAlert);
		waitForAlertResponse(errorAlert);
		return;
	}

	i = fileno(gpicdasmFile);
	fcntl(i, F_SETFL, fcntl(i, F_GETFL, 0) | O_NONBLOCK);

	for (i=0; i<10; i++)
	{
		SDL_Delay(1);

		if (fgets(commandResponse, sizeof(commandResponse) - 1, gpicdasmFile))
		{
			running = TRUE;
			break;
		}
	}

	if (!running)
	{
		sprintf(alertMessage, "     gpicdasm failed!     \n");
		errorAlert->x = 100;
		errorAlert->y = 40;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		popUpWidget(errorAlert);
		waitForAlertResponse(errorAlert);
		gpicdasmFile = NULL;
	}
}

// Issue command to picp

bool issueCommand(int command)
{
	bool	ok;
	int	i, len;
	char	port[32], type[32];
	char	commandString[128];

	i = 0;
	ok = FALSE;					// check that serialPort = '/dev/ttyx' where x = S0-S3 or USB0-USB3

	while (serialPortNames[i])
	{
		len = strlen(serialPortNames[i]);

		if (!strncmp(serialPort, serialPortNames[i], len))
		{
			ok = TRUE;
			break;
		}

		i++;
	}

	if (!ok)
	{
		sprintf(alertMessage, "     Invalid serial port!     \n");
		errorAlert->x = 100;
		errorAlert->y = 40;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		popUpWidget(errorAlert);
		waitForAlertResponse(errorAlert);
		return FALSE;
	}

	for (i=0; serialPort[i]; i++)
	{
		if (serialPort[i] != ' ')
			port[i] = serialPort[i];
		else
			break;
	}

	port[i] = '\0';

	for (i=0; deviceType[i]; i++)
	{
		if (deviceType[i] != ' ')
			type[i] = deviceType[i];
		else
			break;
	}

	type[i] = '\0';

	if (commdbg)
		sprintf(commandString, "%s -c %s %s -", picpCommandName, port, type);
	else
		sprintf(commandString, "%s %s %s -", picpCommandName, port, type);

	if (ISPprog)
		strcat(commandString, "i -");

	switch (command)
	{
		case PICP_COMMAND_GET_DEVICES:			// get supported device types (not implemented - get types from picdev.c)
			sprintf(commandString, "%s", picpCommandName);		// no options to picp
			break;

		case PICP_COMMAND_GET_VERSION:			// get PS+ firmware version
			for (i=0; i<64; i++)						// also check for Warp-13
				warpFWversion[i] = 0;

			strcat(commandString, "v");
			break;

		case PICP_COMMAND_READ_PGM:				// read PIC program from device
		case PICP_COMMAND_VERIFY_PGM:
			extendedAddress = 0;
			recordCount = 0;
			strcat(commandString, "rp");
			break;

		case PICP_COMMAND_WRITE_PGM:				// write program to PIC device
			strcat(commandString, "wp ");
			strcat(commandString, tempFileName);
			break;

		case PICP_COMMAND_READ_ID:					// read ID bits
		case PICP_COMMAND_VERIFY_ID:
			strcat(commandString, "ri");
			break;

		case PICP_COMMAND_WRITE_ID:				// write ID bits
			strcat(commandString, "wi ");
			strcat(commandString, IdText);
			break;

		case PICP_COMMAND_READ_CFG:				// read configuration bits
		case PICP_COMMAND_VERIFY_CFG:
			strcat(commandString, "rc");
			break;

		case PICP_COMMAND_WRITE_CFG:				// write configuration bits
			strcat(commandString, "wc ");
			strcat(commandString, configText);
			break;

		case PICP_COMMAND_READ_DATA:				// read data memory
		case PICP_COMMAND_VERIFY_DATA:
			extendedAddress = 0;
			recordCount = 0;
			strcat(commandString, "rd");
			break;

		case PICP_COMMAND_WRITE_DATA:				// write data memory
			strcat(commandString, "wd ");
			strcat(commandString, tempFileName);
			break;

		case PICP_COMMAND_READ_CAL:				// read calibration
			strcat(commandString, "ro");
			break;

		case PICP_COMMAND_WRITE_CAL:				// write calibration
			strcat(commandString, "wo");
			break;

		case PICP_COMMAND_ERASE_PGM:				// erase program space (non-flash)
			strcat(commandString, "ep");
			break;

		case PICP_COMMAND_ERASE_ID:				// erase ID bits
			strcat(commandString, "ei");
			break;

		case PICP_COMMAND_ERASE_CFG:				// erase configuration bits
			strcat(commandString, "ec");
			break;

		case PICP_COMMAND_ERASE_DATA:				// erase data space
			strcat(commandString, "ed");
			break;

		case PICP_COMMAND_ERASE_FLASH:			// erase flash device
			strcat(commandString, "ef");
			break;

		case PICP_COMMAND_BLANK_CHECK_ALL:		// blank check all regions
			blankCheckBits = 0;
			strcat(commandString, "b");
			break;

		case PICP_COMMAND_GET_PICP_VERSION:		// get picp version number
			sprintf(commandString, "%s -v", picpCommandName);
			break;

		default:			// invalid command!
			sprintf(alertMessage, "     Invalid command to %s!    \n", picpCommandName);
			errorAlert->x = 100;
			errorAlert->y = 40;
			errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
			popUpWidget(errorAlert);
			waitForAlertResponse(errorAlert);
			return FALSE;
			break;
	}

	if (commandFile)
		pclose(commandFile);

	strcat(commandString, " 2>");
	strcat(commandString, errorFileName);

#ifdef DEBUG
	printf("command: %s\n", commandString);
#endif

	commandFile = popen(commandString, "r");		// commandFile captures picp's stdout output

	if (commandFile)
		return TRUE;

	return FALSE;
}

// Get picp's response to a command

bool getCommandResponse(int command)
{
	int	i, checkbits;
	bool	retval = FALSE;
	char	*cptr;

	for (i=0; i<sizeof(commandResponse); i++)
		commandResponse[i] = '\0';

	if (!commandFile)			// picp failed to fork!
	{
		sprintf(alertMessage, "     Failed to run %s!    \n", picpCommandName);
		errorAlert->x = 150;
		errorAlert->y = 40;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		popUpWidget(errorAlert);
		waitForAlertResponse(errorAlert);
		return retval;
	}

	checkbits = 0;

	while (fgets(commandResponse, sizeof(commandResponse) - 1, commandFile))
	{
#ifdef DEBUG
		if (command != PICP_COMMAND_READ_PGM && command != PICP_COMMAND_VERIFY_PGM &&
			 command != PICP_COMMAND_READ_DATA && command != PICP_COMMAND_VERIFY_DATA)
			printf("response: %s\n", commandResponse);
#endif

		switch (command)
		{
			case PICP_COMMAND_READ_PGM:			// parse hex lines from program
				if (commandResponse[0] == ':')
					parseHexLine(commandResponse, picProgramData);
				break;

			case PICP_COMMAND_READ_DATA:			// parse hex lines from data
				if (commandResponse[0] == ':')
					parseHexLine(commandResponse, picDataBuffer);
				break;

			case PICP_COMMAND_BLANK_CHECK_ALL:	// blank check all regions
				i = getBlankCheckBit(commandResponse);

				if (i)
					blankCheckBits |= i;
				break;

			case PICP_COMMAND_VERIFY_PGM:
				if (commandResponse[0] == ':')
					parseHexLine(commandResponse, picProgramTemp);
				break;

			case PICP_COMMAND_VERIFY_DATA:		// verify data
				if (commandResponse[0] == ':')
					parseHexLine(commandResponse, picDataTemp);
				break;

			case PICP_COMMAND_ERASE_FLASH:		// erase flash device
				i = getBlankCheckBit(commandResponse);

				if (i)
					checkbits |= i;
				break;

			case PICP_COMMAND_GET_VERSION:		// picp returns PS+ and/or Warp-13 firmware version
				if (!strncmp(commandResponse, "Warp", 4))
				{
					warpFWversion[0] = '(';

					for (i=0; i<11; i++)
						warpFWversion[i + 1] = commandResponse[i];

					warpFWversion[11] = ' ';
					warpFWversion[12] = commandResponse[14];
					warpFWversion[13] = '.';
					warpFWversion[14] = commandResponse[15];
					warpFWversion[15] = ')';
					warpFWversion[16] = '\0';
				}
				break;

			case PICP_COMMAND_GET_PICP_VERSION:
				if (!strncmp(commandResponse, "picp", 4))
				{
					cptr = (char *) &commandResponse[5];

					while (*cptr && !isdigit(*cptr))		// find version number
						cptr++;

					if (*cptr)
					{
						picpVersion = atoi(cptr);

						while (*cptr && isdigit(*cptr))	// find major rev number
							cptr++;

						cptr++;

						if (*cptr && isdigit(*cptr))
						{
							picpMajorRev = atoi(cptr);

							while (*cptr && isdigit(*cptr))	// find minor rev number
								cptr++;

							cptr++;

							if (*cptr && isdigit(*cptr))
								picpMinorRev = atoi(cptr);
						}
					}
				}
				break;

// nothing special to do for these cases (single line response or not implemented)
			case PICP_COMMAND_GET_DEVICES:		// not implemented - get types from picdev.c
			case PICP_COMMAND_WRITE_PGM:
			case PICP_COMMAND_READ_ID:
			case PICP_COMMAND_WRITE_ID:
			case PICP_COMMAND_READ_CFG:
			case PICP_COMMAND_WRITE_CFG:
			case PICP_COMMAND_WRITE_DATA:
			case PICP_COMMAND_READ_CAL:
			case PICP_COMMAND_WRITE_CAL:
			case PICP_COMMAND_ERASE_PGM:
			case PICP_COMMAND_ERASE_ID:
			case PICP_COMMAND_ERASE_CFG:
			case PICP_COMMAND_ERASE_DATA:
			case PICP_COMMAND_VERIFY_ID:
			case PICP_COMMAND_VERIFY_CFG:
			case PICP_COMMAND_MAX:
			default:
				break;
		}
	}

	retval = TRUE;

	for (i=0; i<10; i++)		// wait for picp to open error file
	{
		errorFile = fopen(errorFileName, "r");		// errorFile captures picp's stderr output

		if (errorFile)		// file is open
			break;
	}

	if (!errorFile)
		printf("ERROR FILE FAILED TO OPEN!!!!\n");

	if (errorFile)		// check for picp stderr output
	{
		if (fgets(errorResponse, sizeof(errorResponse) - 1, errorFile))
		{
			if (!strncmp(errorResponse, "Warp", 4))
			{
				warpFWversion[0] = '(';

				for (i=0; i<11; i++)
					warpFWversion[i + 1] = errorResponse[i];

				warpFWversion[11] = ' ';
				warpFWversion[12] = errorResponse[14];
				warpFWversion[13] = '.';
				warpFWversion[14] = errorResponse[15];
				warpFWversion[15] = ')';
				warpFWversion[16] = '\0';
			}
			else
			{
#ifdef DEBUG
				printf("ERROR: %s\n", errorResponse);
#endif
				// ignore BLANK_CFGBITS in erase flash if oldFirmware

				if (!((command == PICP_COMMAND_ERASE_FLASH) && oldFirmware &&
						(checkbits == (BLANK_PROGRAM | BLANK_IDLOC | BLANK_DATA))))
				{
					strcpy(alertMessage, errorResponse);
					errorAlert->x = 50;
					errorAlert->y = 40;
					errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
					popUpWidget(errorAlert);
					waitForAlertResponse(errorAlert);
					retval = FALSE;
				}
			}
		}

		while (fgets(errorResponse, sizeof(errorResponse) - 1, errorFile))
		{
			if (!strncmp(errorResponse, "Warp", 4))
			{
				warpFWversion[0] = '(';

				for (i=0; i<11; i++)
					warpFWversion[i + 1] = errorResponse[i];

				warpFWversion[11] = ')';
				warpFWversion[12] = '\0';
			}
#ifdef DEBUG
			else
				printf("ERROR: %s\n", errorResponse);
#endif
		}

		fclose(errorFile);
		remove(errorFileName);
		errorFile = NULL;
	}

	pclose(commandFile);		// close connection to picp
	commandFile = NULL;
	return retval;
}

int getBlankCheckBit(char *line)
{
	int	resp;
	bool	yes;
	char	type, *cptr;

	resp = 0;
	yes = FALSE;
	type = toupper(*line);
	cptr = strchr(line, ':');

	if (cptr)		// cptr -> "not blank" or "blank"
	{
		cptr++;
		cptr++;

		if (*cptr == 'b')
			yes = TRUE;
	}

	switch (type)
	{
		case 'P':
			if (yes)
				resp |= BLANK_PROGRAM;
			break;

		case 'C':
			if (yes)
				resp |= BLANK_CFGBITS;
			break;

		case 'I':
			if (yes)
				resp |= BLANK_IDLOC;
			break;

		case 'D':
			if (yes)
				resp |= BLANK_DATA;
			break;
	}

	return resp;
}

// convert two ascii hex characters to an 8-bit unsigned int
//  return zero if out of range (not ascii hex)
unsigned char atoh(char high, char low)
{
	char	hi, lo;
	int	value;

	hi = toupper(high);
	lo = toupper(low);
	value = 0;

	if (hi >= '0' && hi <= '9')
		value += ((hi - '0') << 4);
	else if (hi >= 'A' && hi <= 'F')
		value += ((hi - 'A' + 0x0a) << 4);

	if (lo >= '0' && lo <= '9')
		value += (lo - '0');
	else if (lo >= 'A' && lo <= 'F')
		value += (lo - 'A' + 0x0a);

	return(value);
}

// Set configuration bits from Intel hex record

void setConfigBits(char *line, int len)
{
	int	i;
	char	*text;

	line += 9;
	text = (char *) &configText[0];

	for (i=0; i<len; i += 2)
	{
		*text++ = '0';
		*text++ = 'x';
		*text++ = tolower(*(line + 2));
		*text++ = tolower(*(line + 3));
		*text++ = tolower(*(line + 0));
		*text++ = tolower(*(line + 1));
		*text++ = ' ';
		line += 4;
	}