自学教程：C++ DEBUGSTR函数代码示例

/* Configure ADC ROM Driver and pripheral */static int adcrom_config(void){	ADC_CFG_T cfg = {		ADC_SEQ_A_CONFIG,		ADC_SEQ_B_CONFIG,		ADC_CONFIG,		0	/* Divider will be calculated during run time */	};	cfg.clkDiv = 0xFF;	/* Configure the ADC */	ROM_ADC_Configure(hADC, &cfg);	/* Calibrate the ADC */	if (ROM_ADC_Calibrate(hADC, Chip_Clock_GetSystemClockRate()) != LPC_OK) {		DEBUGSTR("ERROR: Calibrating ADC/r/n");		while (1) {}	}	DEBUGSTR("ADC Initialized and Calibrated successfully!/r/n");	/* Channel configurations */	ROM_ADC_ConfigureCh(hADC, 0, ADC_CH_THRES_DATA | ADC_CH_THRES_SEL1 | ADC_CH_THRES_CROSSING);	ROM_ADC_ConfigureCh(hADC, 1, ADC_CH_THRES_DATA);	return 0;}

/* Function to initialize the IPC message queue */void IPC_initMsgQueue(void *data, int size, int count){	struct ipc_queue *qrd;	/* Sanity Check */	if (!size || !count || !data) {		DEBUGSTR("ERROR:IPC Queue size invalid parameters/r/n");		while (1) {}	}	/* Check if size is a power of 2 */	if (count & (count - 1)) {		DEBUGSTR("ERROR:IPC Queue size not power of 2/r/n");		while (1) {	/* BUG: Size must always be power of 2 */		}	}	qrd   = &q_ipc[CPUID_CURR];	memset(qrd, 0, sizeof(*qrd));	qrd->count = count;	qrd->size = size;	qrd->data = data;	qrd->valid = QUEUE_MAGIC_VALID;	if (!IPC_EventHandler) {		IPC_EventHandler = IPC_EventHandler_sa;	}}

/***************************************************************************** * Private functions ****************************************************************************/static void PMC_Get_Wakeup_option(uint8_t *Wakeup_rtc){	FlagStatus exitflag;	uint8_t buffer = 0xFF;	DEBUGSTR(menu1);	exitflag = RESET;	while (exitflag == RESET) {		/* Get user input */		buffer = DEBUGIN();		if ((buffer == 'W') || (buffer == 'w')) {			DEBUGSTR("WAKEUP0 pin selected /r/n");			*Wakeup_rtc = 0;			exitflag = SET;		}		if ((buffer == 'R') || (buffer == 'r')) {			DEBUGSTR("RTC Alarm selected /r/n");			*Wakeup_rtc = 1;			exitflag = SET;		}	}}

void DoneHooksReg(){#ifdef HOOKS_USE_VIRT_REGISTRY#ifdef _DEBUG	//WARNING!!! OutputDebugString must NOT be used from ConEmuHk::DllMain(DLL_PROCESS_DETACH). See Issue 465	DEBUGSTR(L"ConEmuHk: Deinitializing registry virtualization!/n");#endif	if (gpRegKeyHooks)	{		free(gpRegKeyHooks);		gpRegKeyHooks = NULL;	}	CloseRootKeys();	if (gpRegKeyStore)	{		gpRegKeyStore->Free();		free(gpRegKeyStore);		gpRegKeyStore = NULL;	}#ifdef _DEBUG	//WARNING!!! OutputDebugString must NOT be used from ConEmuHk::DllMain(DLL_PROCESS_DETACH). See Issue 465	DEBUGSTR(L"ConEmuHk: Registry virtualization deinitialized!/n");#endif#endif}

/* *  FUNCTION: TaperDegreesToDistance * *  PARAMETERS:		p 	-- Pointer to Menu * *  USES GLOBALS: * *  DESCRIPTION:		Convert the full angle degrees to inch/foot of diameter. * * *  RETURNS:  * */int8 TaperDegreesToDistance(TMENU_DATA * p) {	// Convert the included angle in degrees to inch/inch of diameter.	p->Data.FloatValue = tan((p->Data.FloatValue)/2 * RADIANS_PER_DEGREE)*2;	// Then check if metric measurements are wanted.	if (p->Dependancy != (uint8)0) {	//		DEBUGSTR("To Metric Var is dependant on %02X/n",p->Dependancy );		// First get menu from FLASH into data structure	  	memcpypgm2ram(			(void *)&d, 			(MEM_MODEL rom void *)&MenuData[p->Dependancy],  			sizeof(TMENU_DATA)			);		// Then test the flag.		if (GetFlagVar(&d)) {	// If the metric flag is set convert the value to metric.			DEBUGSTR("Convert to Metric/n");			p->Data.FloatValue *= 25.4;				return('m');		}		else			return('"');		}	else		return(' ');}

/* Using printf might cause text section overflow */static void Print_Val(const char *str, uint32_t val){	char buf[9];	int ret;	buf[8] = 0;	DEBUGSTR(str);	ret = Hex2Str(buf, val);	DEBUGSTR(&buf[8 - ret]);	DEBUGSTR("/r/n");}

bool InitHooksReg(){	bool lbRc = false;#ifdef HOOKS_USE_VIRT_REGISTRY	CESERVER_CONSOLE_MAPPING_HDR* pInfo = GetConMap();	if (!pInfo || !(pInfo->isHookRegistry&1) || !*pInfo->sHiveFileName)		return false;	DEBUGSTR(L"ConEmuHk: Preparing for registry virtualization/n");	HookItem HooksRegistry[] =	{		/* ************************ */		{(void*)OnRegCloseKey,		"RegCloseKey",		advapi32},		{(void*)OnRegCreateKeyA,	"RegCreateKeyA",	advapi32},		{(void*)OnRegCreateKeyW,	"RegCreateKeyW",	advapi32},		{(void*)OnRegCreateKeyExA,	"RegCreateKeyExA",	advapi32},		{(void*)OnRegCreateKeyExW,	"RegCreateKeyExW",	advapi32},		{(void*)OnRegOpenKeyA,		"RegOpenKeyA",		advapi32},		{(void*)OnRegOpenKeyW,		"RegOpenKeyW",		advapi32},		{(void*)OnRegOpenKeyExA,	"RegOpenKeyExA",	advapi32},		{(void*)OnRegOpenKeyExW,	"RegOpenKeyExW",	advapi32},		{(void*)OnRegDeleteKeyA,	"RegDeleteKeyA",	advapi32},		{(void*)OnRegDeleteKeyW,	"RegDeleteKeyW",	advapi32},		/* ************************ */		{(void*)OnRegConnectRegistryA,	"RegConnectRegistryA",	advapi32},		{(void*)OnRegConnectRegistryW,	"RegConnectRegistryW",	advapi32},		/* ************************ */		{0}	};	lbRc = (InitHooks(HooksRegistry) >= 0);	if (lbRc)	{		PrepareHookedKeyList();		DEBUGSTR(L"ConEmuHk: Registry virtualization prepared/n");		// Если advapi32.dll уже загружена - можно сразу дернуть экспорты		if (ghAdvapi32)		{			RegOpenKeyEx_f = (RegOpenKeyEx_t)GetProcAddress(ghAdvapi32, "RegOpenKeyExW");			RegCreateKeyEx_f = (RegCreateKeyEx_t)GetProcAddress(ghAdvapi32, "RegCreateKeyExW");			RegCloseKey_f = (RegCloseKey_t)GetProcAddress(ghAdvapi32, "RegCloseKey");		}	}	else	{		DEBUGSTR(L"ConEmuHk: Registry virtualization failed!/n");	}	#else	lbRc = true;#endif	return lbRc;}

 /** * @brief	Main entry point * @return	Nothing */int main(void){	SPIFIobj *obj = &spifi_obj;	uint32_t spifi_clk_mhz;	SPIFIopers opers;	int ret;	spifi_rom_init(spifi);		/* Initialize the board & LEDs for error indication */	Board_Init();		/* Since this code runs from SPIFI no special initialization required here */	prepare_write_data(data_buffer, sizeof(data_buffer));	spifi_clk_mhz = Chip_Clock_GetRate(CLK_MX_SPIFI) / 1000000;		/* Typical time tCS is 20 ns min, we give 200 ns to be on safer side */	if (spifi_init(obj, spifi_clk_mhz / 5, S_RCVCLK | S_FULLCLK, spifi_clk_mhz)) {		DEBUGSTR("Error initializing SPIFI interface!/r/n");		Board_LED_Set(1, 1);		goto end_prog;	}		/* Prepare the operations structure */	memset(&opers, 0, sizeof(SPIFIopers));	opers.dest = (char *) SPIFI_WRITE_SECTOR_OFFSET;	opers.length = sizeof(data_buffer);	/* opers.options = S_VERIFY_PROG; */		/* NOTE: All interrupts must be disabled before calling program as	 * any triggered interrupts might attempt to run a code from SPIFI area	 */	ret = spifi_program(obj, (char *) data_buffer, &opers);	if (ret) {		DEBUGOUT("Error 0x%x: Programming of data buffer to SPIFI Failed!/r/n", ret);		Board_LED_Set(1, 1);		goto end_prog;	}	DEBUGSTR("SPIFI Programming successful!/r/n");	if (verify_spifi_data((uint8_t *) SPIFI_WRITE_SECTOR_ADDRESS, sizeof(data_buffer))) {		DEBUGSTR("Error verifying the SPIFI data/r/n");		Board_LED_Set(1, 1);		goto end_prog;	}	Board_LED_Set(0, 1);	DEBUGSTR("SPIFI Data verified!/r/n");end_prog:	while(1) {__WFI();}}

/* Show RTC time in UT format */static void showTime(uint32_t rtcCount){	struct tm currTime;#ifdef USE_CASCTIME	char tempBuff[256];#endif	ConvertRtcTime(rtcCount, &currTime);#ifdef USE_CASCTIME	DEBUGOUT(asctime_r(&currTime, tempBuff));#else	DEBUGOUT("Raw RTC tick value = %u/r/n", rtcCount);	/* Todays date */	DEBUGOUT("DATE: %02d:%02d:%04d/r/n", currTime.tm_mon + 1,			 currTime.tm_mday, (currTime.tm_year + TM_YEAR_BASE));	/* Current time */	DEBUGOUT("TIME: %02d:%02d:%02d/r/n", currTime.tm_hour, currTime.tm_min, currTime.tm_sec);	/* Day of week and year */	DEBUGOUT("tm_wday = %01d, tm_yday = %03d/r/n", currTime.tm_wday,			 currTime.tm_yday);#endif	DEBUGSTR("/r/n");}

/** * @brief	main routine for ADC example * @return	Function should not exit */int main(void){	uint16_t dataADC;	int j;	SystemCoreClockUpdate();	Board_Init();	Init_ADC_PinMux();	DEBUGSTR("ADC Demo/r/n");	/* ADC Init */	Chip_ADC_Init(LPC_ADC, &ADCSetup);	Chip_ADC_EnableChannel(LPC_ADC, ADC_CH0, ENABLE);	while (1) {		/* Start A/D conversion */		Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);		/* Waiting for A/D conversion complete */		while (Chip_ADC_ReadStatus(LPC_ADC, ADC_CH0, ADC_DR_DONE_STAT) != SET) {}		/* Read ADC value */		Chip_ADC_ReadValue(LPC_ADC, ADC_CH0, &dataADC);		/* Print ADC value */		DEBUGOUT("ADC value is 0x%x/r/n", dataADC);		/* Delay */		j = 500000;		while (j--) {}	}	/* Should not run to here */	return 0;}

/** * @brief	MRT example main function * @return	Status (This function will not return) */int main(void){	int mrtch;	/* Generic Initialization */	SystemCoreClockUpdate();	Board_Init();	DEBUGSTR("LPC15xx MRT Example /r/n");	/* MRT Initialization and disable all timers */	Chip_MRT_Init();	for (mrtch = 0; mrtch < MRT_CHANNELS_NUM; mrtch++) {		Chip_MRT_SetDisabled(Chip_MRT_GetRegPtr(mrtch));	}	/* Enable the interrupt for the MRT */	NVIC_EnableIRQ(MRT_IRQn);	/* Enable timers 0 and 1 in repeat mode with different rates */	setupMRT(0, MRT_MODE_REPEAT, 2);/* 2Hz rate */	setupMRT(1, MRT_MODE_REPEAT, 5);/* 5Hz rate */	/* Enable timer 2 in single one mode with the interrupt restarting the	   timer */	setupMRT(2, MRT_MODE_ONESHOT, 7);	/* Will fire in 1/7 seconds */	/* All processing and MRT reset in the interrupt handler */	while (1) {		__WFI();	}	return 0;}

void CConEmuPipe::Close(){	SafeCloseHandle(mh_Pipe);	SafeFree(pIn);	SafeFree(pOut);	DEBUGSTR(L"Pipe::Close()/n");}

// Find the name of the DLL and inject it.BOOL Inject( LPPROCESS_INFORMATION ppi ){  DWORD len;  WCHAR dll[MAX_PATH];  int	type;#if (MYDEBUG > 0)  if (GetModuleFileNameEx( ppi->hProcess, NULL, dll, lenof(dll) ))    DEBUGSTR( L"%s", dll );#endif  type = ProcessType( ppi );  if (type == 0)    return FALSE;  len = GetModuleFileName( NULL, dll, lenof(dll) );  while (dll[len-1] != '//')    --len;#ifdef _WIN64  wsprintf( dll + len, L"ANSI%d.dll", type );  if (type == 32)    InjectDLL32( ppi, dll );  else    InjectDLL64( ppi, dll );#else  wcscpy( dll + len, L"ANSI32.dll" );  InjectDLL32( ppi, dll );#endif  return TRUE;}

BOOL WINAPI MyCreateProcessW( LPCWSTR lpApplicationName,			      LPWSTR lpCommandLine,			      LPSECURITY_ATTRIBUTES lpThreadAttributes,			      LPSECURITY_ATTRIBUTES lpProcessAttributes,			      BOOL bInheritHandles,			      DWORD dwCreationFlags,			      LPVOID lpEnvironment,			      LPCWSTR lpCurrentDirectory,			      LPSTARTUPINFOW lpStartupInfo,			      LPPROCESS_INFORMATION lpProcessInformation ){  PROCESS_INFORMATION pi;  if (!CreateProcessW( lpApplicationName,		       lpCommandLine,		       lpThreadAttributes,		       lpProcessAttributes,		       bInheritHandles,		       dwCreationFlags | CREATE_SUSPENDED,		       lpEnvironment,		       lpCurrentDirectory,		       lpStartupInfo,		       &pi ))    return FALSE;  DEBUGSTR( L"CreateProcessW: /"%s/", /"%s/"",	    (lpApplicationName == NULL) ? L"" : lpApplicationName,	    (lpCommandLine == NULL) ? L"" : lpCommandLine );  Inject( &pi, lpProcessInformation, dwCreationFlags );  return TRUE;}

/** Initialize the CGI environment *	This function registers the pairs of file's name and CGI function for the HTTPD server * @returns nothing*/void initCGIs( void) {	http_set_cgi_handlers(cgi_handlers, (sizeof (cgi_handlers) / sizeof (tCGI) ) );	DEBUGSTR("httpCGIHandlers registered...............[OK]/r/n");	return;}

BOOL HookAPIAllMod( PHookFn Hooks, BOOL restore ){  HANDLE	hModuleSnap;  MODULEENTRY32 me;  BOOL		fOk;  // Take a snapshot of all modules in the current process.  hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE,					  GetCurrentProcessId() );  if (hModuleSnap == INVALID_HANDLE_VALUE)  {    DEBUGSTR( L"error: %S(%d)", __FILE__, __LINE__ );    return FALSE;  }  // Fill the size of the structure before using it.  me.dwSize = sizeof(MODULEENTRY32);  // Walk the module list of the modules.  for (fOk = Module32First( hModuleSnap, &me ); fOk;       fOk = Module32Next( hModuleSnap, &me ))  {    // We don't hook functions in our own module.    if (me.hModule != hDllInstance && me.hModule != hKernel)    {      //attempting to ignore NVIDIA 3D wrapper modules that seem to be in conflict on some systems      if (_wcsnicmp(me.szModule, L"nvd3d9wrap", 10) == 0)      {       	DEBUGSTR(L"Ignoring %s", me.szModule);       	continue;      }            DEBUGSTR( (restore) ? L"Unhooking from %s" : L"Hooking in %s",		me.szModule );      // Hook this function in this module.      if (!HookAPIOneMod( me.hModule, Hooks, restore ))      {	CloseHandle( hModuleSnap );	return FALSE;      }    }  }  CloseHandle( hModuleSnap );  return TRUE;}

void showData(char *reg, uint16_t *dat){	int i, j;	DEBUGSTR("Showing data from :");	DEBUGSTR(reg);	DEBUGSTR("/r/n");	/* Hard coded for a 2x8 16-bit displays */	for (i = 0; i < 2; i++) {		for (j = 0; j < 8; j++) {			Print_Val16(*dat);			dat++;		}		DEBUGSTR("/r/n");	}}

/* Prints the information of the M0/M4 image to screen */static void print_image_info(const char *pre, const struct image_sig *img){	DEBUGSTR("***************************************/r/n");	DEBUGOUT("%s: Header found at %p/r/n", pre, img);	DEBUGOUT("%s: Included Examples: %s%s%s%s%s/r/n", pre,			 img->capability & EX_BLINKY  ? "BLINKY" : "",			 img->capability & EX_USBHOST ? ", USB_Host" : "",			 img->capability & EX_USBDEV  ? ", USB_Device" : "",			 img->capability & EX_LWIP    ? ", lwIP" : "",			 img->capability & EX_EMWIN   ? ", emWin" : "");	DEBUGOUT("%s: OS Used: %s/r/n", pre,			 img->os == 1 ? "NONE (STANDALONE)" :			 (img->os == 2 ? "FreeRTOS" : "UCOS-III"));	DEBUGOUT("%s: Built on %s %s/r/n", pre,			 img->build_date,			 img->build_time);	DEBUGSTR("***************************************/r/n");}

HMODULE WINAPI MyLoadLibraryW( LPCWSTR lpFileName ){  HMODULE hMod = LoadLibraryW( lpFileName );  if (hMod && hMod != hKernel)  {    DEBUGSTR( L"Hooking in %s (LoadLibraryW)", lpFileName );    HookAPIOneMod( hMod, Hooks, FALSE );  }  return hMod;}

FARPROC WINAPI MyGetProcAddress( HMODULE hModule, LPCSTR lpProcName ){  PHookFn hook;  FARPROC proc;  proc = GetProcAddress( hModule, lpProcName );  if (proc)  {    if (hModule == hKernel)    {      // Ignore LoadLibrary so other hooks continue to work (our version      // might end up at a different address).      if (proc == Hooks[0].oldfunc || proc == Hooks[1].oldfunc)	return proc;      for (hook = Hooks+2; hook->name; ++hook)      {	if (proc == hook->oldfunc)	{	  DEBUGSTR( L"GetProcAddress: %S", lpProcName );	  return hook->newfunc;	}      }    }    else if (Hooks[0].apifunc) // assume if one is defined, all are    {      if (proc == Hooks[0].apifunc || proc == Hooks[1].apifunc)	return proc;      for (hook = Hooks+2; hook->name; ++hook)      {	if (proc == hook->apifunc)	{	  DEBUGSTR( L"GetProcAddress: %S", lpProcName );	  return hook->newfunc;	}      }    }  }  return proc;}

int8SetOnboardStepper(TMENU_DATA * p) {	DEBUGSTR("Enabling SPI MicroStepper/n");	SSPSTAT = 0x40;		// Transmit on clock high.	SSPCON1	= 0x20;		// FOsc/4, Enable SPI, Clock Idle Low.	bMOTOR_LATCH = 0;	SSPBUF = 0;	fStepHappened = 0;	// Prevent shutdown from doing anything to motor.	MicroStep(0,0);		// Set motor off.}

HMODULE WINAPI MyLoadLibraryExW( LPCWSTR lpFileName, HANDLE hFile,				 DWORD dwFlags ){  HMODULE hMod = LoadLibraryExW( lpFileName, hFile, dwFlags );  if (hMod && hMod != hKernel && !(dwFlags & LOAD_LIBRARY_AS_DATAFILE))  {    DEBUGSTR( L"Hooking in %s (LoadLibraryExW)", lpFileName );    HookAPIOneMod( hMod, Hooks, FALSE );  }  return hMod;}

/* Function to blink the LED to show the error code * caused by M0 image boot failure */static void booting_m0_failure(uint32_t msec){	int32_t cnt = 60000 / (msec * 2);	DEBUGSTR("ERROR: Boot failure!!/r/n");	while (cnt--) {		Board_LED_Set(ERROR_LED, 1);		MSleep(msec);		Board_LED_Set(ERROR_LED, 0);		MSleep(msec);	}}

void CGestures::DumpGesture(LPCWSTR tp, const GESTUREINFO& gi){	wchar_t szDump[256];	_wsprintf(szDump, SKIPLEN(countof(szDump))		L"Gesture(x%08X {%i,%i} %s",		(DWORD)gi.hwndTarget, gi.ptsLocation.x, gi.ptsLocation.y,		tp); // tp - имя жеста	switch (gi.dwID)	{	case GID_PRESSANDTAP:		{			DWORD h = LODWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)				L" Dist={%i,%i}", (int)(short)LOWORD(h), (int)(short)HIWORD(h));			break;		}	case GID_ROTATE:		{			DWORD h = LODWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)				L" %i", (int)LOWORD(h));			break;		}	}	if (gi.dwFlags&GF_BEGIN)		wcscat_c(szDump, L" GF_BEGIN");	if (gi.dwFlags&GF_END)		wcscat_c(szDump, L" GF_END");	if (gi.dwFlags&GF_INERTIA)	{		wcscat_c(szDump, L" GF_INERTIA");		DWORD h = HIDWORD(gi.ullArguments); _wsprintf(szDump+_tcslen(szDump), SKIPLEN(32)			L" {%i,%i}", (int)(short)LOWORD(h), (int)(short)HIWORD(h));	}	if (gpSetCls->isAdvLogging >= 2)	{		gpConEmu->LogString(szDump);	}	else	{		#ifdef USE_DUMPGEST		wcscat_c(szDump, L")/n");		DEBUGSTR(szDump);		#endif	}}

/* Prints an 8-bit value */static void Print_Val16(uint16_t val){	char buf[] = "0xXXXX ";	buf[5] = "0123456789ABCDEF"[val & 0x0F];	val >>= 4;	buf[4] = "0123456789ABCDEF"[val & 0x0F];	val >>= 4;	buf[3] = "0123456789ABCDEF"[val & 0x0F];	val >>= 4;	buf[2] = "0123456789ABCDEF"[val & 0x0F];	DEBUGSTR(buf);}

//Initialise cgi environmentint CGIinit( void) {//	cgi_handler.pcCGIName = "/actuadores.cgi";////	cgi_handler.pfnCGIHandler = actuatorsHandler;	http_set_cgi_handlers(cgi_handlers, 2);	DEBUGSTR("httpCGIHandler initialized............[OK]/r/n");	return 0;}

BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved ){  BOOL	  bResult = TRUE;  HMODULE api;  PHookFn hook;  if (dwReason == DLL_PROCESS_ATTACH)  {    hDllInstance = hInstance; // save Dll instance handle    DEBUGSTR( L"hDllInstance = %p", hDllInstance );    // Get the entry points to the original functions.    hKernel = GetModuleHandleA( APIKernel );    for (hook = Hooks; hook->name; ++hook)    {      hook->oldfunc = GetProcAddress( hKernel, hook->name );      api = GetModuleHandleA( hook->lib );      if (api)	hook->apifunc = GetProcAddress( api, hook->name );    }    bResult = HookAPIAllMod( Hooks, FALSE );    OriginalAttr();    DisableThreadLibraryCalls( hInstance );  }  else if (dwReason == DLL_PROCESS_DETACH)  {    if (lpReserved == NULL)    {      DEBUGSTR( L"Unloading" );      HookAPIAllMod( Hooks, TRUE );    }    else    {      DEBUGSTR( L"Terminating" );    }  }  return( bResult );}

/* Get a string to save from the UART */static uint32_t MakeString(uint8_t *str){	int index, byte;	char strOut[2];	/* Get a string up to 32 bytes to write into Flash */	DEBUGSTR("/r/nEnter a string to write into Flash/r/n");	DEBUGSTR("Up to 32 bytes in length, press ESC to accept/r/n");	/* Setup header */	strncpy((char *) str, CHKTAG, CHKTAG_SIZE);	/* Read until escape, but cap at 32 characters */	index = 0;	strOut[1] = '/0';#if defined(DEBUG_ENABLE)	byte = DEBUGIN();	while ((index < 32) && (byte != ESC_CHAR)) {		if (byte != EOF) {			strOut[0] = str[4 + index] = (uint8_t) byte;			DEBUGSTR(strOut);			index++;		}		byte = DEBUGIN();	}#else	/* Suppress warnings */	(void) byte;	(void) strOut;	/* Debug input not enabled, so use a pre-setup string */	strncpy((char *) &str[4], "12345678", 8);	index = 8;#endif	str[3] = (uint8_t) index;	return (uint32_t) index;}

/* initialization routine for Multicore examples */static void prvSetupHardware(void){	SystemCoreClockUpdate();	Board_Init();	/* Time to Start M0APP */	if (M0Image_Boot(CPUID_M0APP, (uint32_t) BASE_ADDRESS_M0APP) < 0) {		DEBUGSTR("Unable to BOOT M0APP Core!");	}#ifdef BASE_ADDRESS_M0SUB	if (M0Image_Boot(CPUID_M0SUB, (uint32_t) BASE_ADDRESS_M0SUB) < 0) {		DEBUGSTR("Unable to BOOT M0SUB Core!");	}#endif	/* Initialize the IPC Queue */	IPCEX_Init();	/* Start the tick timer */	SysTick_Config(SystemCoreClock / 1000);}

/* *  FUNCTION: TaperDistanceToDegrees * *  PARAMETERS:		p 	-- Pointer to Menu * *  USES GLOBALS: * *  DESCRIPTION:	Convert taper in inch/ft to degrees. * *  RETURNS: 		Nothing. * */int8 TaperDistanceToDegrees(TMENU_DATA * p) {	// Conversions are often dependant on whether another flag is set.	if (p->Dependancy != (uint8)0) {	//		DEBUGSTR("To Imperial Var is dependant on %02X/n",p->Dependancy );		// First get menu from FLASH into data structure	  	memcpypgm2ram(			(void *)&d, 			(MEM_MODEL rom void *)&MenuData[p->Dependancy], 			sizeof(TMENU_DATA)			);		// Then test the flag.		if (GetFlagVar(&d)) {	// If the metric flag is set convert the value to imperial.			DEBUGSTR("Convert to Imperial/n");			p->Data.FloatValue /= 25.4;		}		}	// Now we know we have imperial units in inch per inch and then degrees	// finally change that to (included) angle degrees.	p->Data.FloatValue = (atan(p->Data.FloatValue / 2) / RADIANS_PER_DEGREE) * 2;	return(' ');}