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

void taskExecuter(void *param){    printf(">>[Executer] Started/n");    ExeCmd RunCmd;    int cmdStat, queueStat, cmdParam;    while(1)    {        /* Read the CMD that Dispatcher sent - BLOCKING */        queueStat = xQueueReceive(executerCmdQueue, &RunCmd, portMAX_DELAY);        if(queueStat == pdPASS)        {            printf("[Executer] Running a command.../n");            /* Commands may take a long time, so reset the WDT */            ClrWdt();            /* Execute the command */            cmdParam = RunCmd.param;            cmdStat = RunCmd.fnct((void *)&cmdParam);            /* Commands may take a long time, so reset the WDT */            ClrWdt();            printf("[Executer] Command result: %d/n", cmdStat);            /* Send the result to Dispatcher - BLOCKING */            xQueueSend(executerStatQueue, &cmdStat, portMAX_DELAY);        }    }}

// Sleep mode - External peripherals all allowed to run unless specifiedvoid SystemPwrSave(unsigned short NapSetting){	//KL WARNING - modified for simpler behaviour, manage your own interrupt wake sources	uint16_t IPLshadow; // Interrupt context saving	IPLshadow = SRbits.IPL;	SRbits.IPL = 0b111;	// Stop all interrupts from vectoring	/*Note: Add/remove power down settings as needed*/	U1PWRCbits.USBPWR = 0; // MCHP Bug, not cleared in usb detach +120uA	// Wdt	if (NapSetting & WAKE_ON_WDT)		{ClrWdt();RCONbits.SWDTEN = 1;}	// Turn on WDT	// Go to sleep... zzzzzzzzzzzzzz	if(NapSetting & LOWER_PWR_SLOWER_WAKE)	RCONbits.PMSLP = 0;	else 									RCONbits.PMSLP = 1; 	Sleep();	__builtin_nop();	// ON RETURN FROM SLEEP 	if (NapSetting & WAKE_ON_WDT)		{ClrWdt();RCONbits.SWDTEN = 0;}	// Turn off WDT	SRbits.IPL = IPLshadow; // Effectively re-enable ints - will vector if flags are set!    return ;                       }

void drp_debug5(void){    int value=0, res=0;    unsigned int index;    printf("dat_reset_Payload_Buff()../n");    int pay_i; int lenBuff=10, r_nextIndx, r_MaxIndx;    for(pay_i=0; pay_i<dat_pay_last_one; pay_i++, lenBuff=lenBuff+1){        printf("  writing: ");        dat_reset_Payload_Buff(pay_i, lenBuff, 0);        printf("    dat_reset_Payload_Buff(%d, %d)/r/n", pay_i, lenBuff);        printf("  reading: ");        r_nextIndx = dat_get_NextPayIndx(pay_i);        printf("    dat_get_NextPayIndx(%u) = %d    |    ", pay_i, r_nextIndx);        r_MaxIndx = dat_get_MaxPayIndx(pay_i);        printf("    dat_get_MaxPayIndx(%u) = %d    |    /n", pay_i, r_MaxIndx);        printf("  comparing: ");        if( r_nextIndx==0 && r_MaxIndx==(lenBuff-1) ){ printf("ok/n"); }        else{ printf("fail/n"); return; }        ClrWdt();    }    printf("DAT_Payload_Buff../n");    int maxind; BOOL st;    for(pay_i=0; pay_i<dat_pay_last_one; pay_i++){        value=20000;        st = TRUE;        maxind = dat_get_MaxPayIndx(pay_i);        for(index=0; st==TRUE; index++, value++){            printf("  writing: ");            dat_set_Payload_Buff(pay_i, value, DAT_PAYBUFF_MODE_NO_MAXINDX);            printf("    DAT_Payload_Buff[%u][%u] = %d    |    ",pay_i, index, value);            printf("%d/%d [NextIndx/MaxIndx]   |    /n", dat_get_NextPayIndx(pay_i), dat_get_MaxPayIndx(pay_i) );            printf("  reading: ");            dat_get_Payload_Buff(pay_i, index, &res);            printf("    DAT_Payload_Buff[%u][%u] = %d    |    /n",pay_i,  index, res);            printf("  comparing: ");            if( value==res ){ printf("ok/n"); }            else{ printf("fail/n"); return; }            if( dat_isFull_Payload_Buff(pay_i)==TRUE){                printf("    DAT_Payload_Buff[%u] esta lleno/r/n", pay_i);                st = FALSE;            }            ClrWdt();        }        printf("*******************************************/n");    }    printf("End of drp_debug5/n");}

/**------------------------------------------------------------------------------* void APP-task(void)*------------------------------------------------------------------------------*/void APP_task(void){	UINT8 i,*ptr, data;	UINT32 addr;	UINT8 resetBuzzer = TRUE;	ias.curAppTime = GetAppTime();											//Fetches the application time from timer driver	if(ias.preAppTime != ias.curAppTime)	{		ias.preAppTime = ias.curAppTime;		for(i = 0; i <MAX_ISSUES; i++)										//check for timeout of issues raised		{			if(ias.issues[i].state == ISSUE_RAISED )			{				ias.issues[i].timeout -= 1;							ptr = (UINT8*)&ias.issues[i].timeout;				data = *ptr;				addr = (i*ISSUE_ENTRY_SIZE)+ISSUE_TIMEOUT;				Write_b_eep((i*ISSUE_ENTRY_SIZE)+ISSUE_TIMEOUT, *ptr);				Busy_eep();				ClrWdt();				data=*(ptr+1);				addr = (i*ISSUE_ENTRY_SIZE)+ISSUE_TIMEOUT+1;				Write_b_eep((i*ISSUE_ENTRY_SIZE)+ISSUE_TIMEOUT+1, *(ptr+1));				Busy_eep();				ClrWdt();			}		}		if(update_timeouts() == TRUE)		{			LAMP_RED = 1;			if( ias.issues_raised == 0 )			{				LAMP_YELLOW = 0;				LAMP_GREEN = 0;			}		}		if(ias.updateCount >= 5)		{			ias.updateCount = 0;			update();		}	}	++ias.updateCount;	}

void APP_clearIssues(){	UINT16 i;	ias.state = ISSUE_RESOLVED;	ias.issues_raised = 0;														//No. of raised issues should be 0 initially	ias.issues_critical = 0;													//No. of critical issues should be 0 initially	ias.preAppTime = 0;	ias.curAppTime = 0;	ias.openIssue = 0;	log.index = 0;	log.prevIndex = 0;	for( i = 0 ; i < MAX_ISSUES; i++)	{		ias.issues[i].state = ISSUE_RESOLVED;		ias.issues[i].timeout = 0;		ias.issues[i].ackStatus = 0;		memset(ias.issues[i].data , 0 , MAX_KEYPAD_ENTRIES + 1);		ClrWdt();	}	for(i = 0; i < (ISSUE_ENTRY_SIZE * MAX_ISSUES); i++)	{		Write_b_eep(i,0);		Busy_eep();		ClrWdt();	}	for( i = 1 ; i <= MAX_DEPARTMENTS ; i++)	{		ias.department_raised[i] = 0 ;	}	writeDeptRaise();/*	if( ias.logonStatus == 1 )	{		updateIndication(1,0,0,0);	}	else		updateIndication(0,0,0,0);*/	}

void drp_debug3(void){    int value=0, res=0;    unsigned int index;    unsigned long block;    con_printf("(Destructive) Testing -256block r/w- memSD/r/n");    for(block=0; block<1024; block=block+256){        printf("testing 256Block = %lu/n", block);        value=20000;        for(index=0; index<=0xFFFF; index++, value++){            con_printf("writing: ");            msd_setVar_256BlockExtMem( block, index, value);            printf("value[%u] = %d    |    ", index, value);            printf("reading: ");            msd_getVar_256BlockExtMem( block, index, &res);            printf("value[%u] = %d    |    ", index, res);            printf("comparing: ");            if( value==res ){ printf("ok/n"); }            else{ con_printf("fail/n"); return; }            ClrWdt();        }    }    //drp_memSD_BlockErase();}

void InitializeOS() {    ClrWdt();    // High priority tasks that must be run all the time    core_task = RegisterTask("Core", ProcessCore);    core_task->state = tsRun;    // Drawing, only needs to be run when screen is on    draw_task = RegisterTask("Draw", DrawLoop);    // Initialize button interrupts    _CNIEn(BTN1_CN) = 1;    _CNIEn(BTN2_CN) = 1;    _CNIEn(BTN3_CN) = 1;    _CNIEn(BTN4_CN) = 1;    cn_register_cb(_CNIDX(BTN1_CN), _PINREF(BTN1), OnBTN1Change);    cn_register_cb(_CNIDX(BTN2_CN), _PINREF(BTN2), OnBTN2Change);    cn_register_cb(_CNIDX(BTN3_CN), _PINREF(BTN3), OnBTN3Change);    cn_register_cb(_CNIDX(BTN4_CN), _PINREF(BTN4), OnBTN4Change);    uint i;    for (i=1; i<=4; i++) {        btn_debounce_tick[i] = 0;        btn_state[i] = 0;    }}

//***************************************************************************// Main() - Main Routine//***************************************************************************void main(){    OSCCON = 0xF0;      //Initialitation of Internal Oscillator    OSCTUNEbits.PLLEN = 1;    hardware_setup();   //Hardware initialization    if ( !vscp_check_pstorage() )   // Check VSCP persistent storage and        init_app_eeprom();          // restore if needed    init_app_ram();     // Initialize data    vscp_init();                    // Initialize the VSCP functionality        while(1){ //Handler scheduler        ClrWdt();			// Feed the dog        if(timeEvent._10mS){    //10mS Event            timeEvent._10mS = 0;            vscp_10mS_Running();            hardware_10mS();        }        if(timeEvent._100mS){   //100mS Event            timeEvent._100mS = 0;            vscp_100mS_Running();            vscp_ledActivity();        }        if(timeEvent._1s){      //1second Event            timeEvent._1s = 0;            vscp_doOneSecondWork(); // Do VSCP one second jobs            greenLed_pin = !greenLed_pin;        }        vscp_freeRunning();                //TODO: Handling the override event    }}

void _ISR_PSV _U2TXInterrupt(void)  {    //InterruptTest5++;    _U2TXIF = 0;                        // interrupt flag reset    unsigned char debugTX;    IFS1bits.U2TXIF = 0;    // clear TX interrupt flag    __builtin_disi(0x3FFF); //disable interrupts up to priority 6 for n cycles    ClrWdt();                           // [1]    if(TxNByte_UART2)    {   debugTX =  *TxPointer_UART2++;       //  Trasmette il carattere del buffer puntato da TxPointer        U2TXREG = debugTX;        TxNByte_UART2 = TxNByte_UART2 - 1;  // TxNByte_UART2--; non pare funzionare    }    else    {        TxComplete[PORT_COM2] = TRUE;        IEC1bits.U2TXIE = 0;            //  Disable Transmit Interrupts    }    DISICNT = 0; //re-enable interrupts    //InterruptTest5--;}

void IAS_acknowledgeIssues(UINT8 ID){	UINT8 i;	ias.issues[ID].ackStatus = 0;	updateLog(ias.issues[ID].data);		Write_b_eep((ID*ISSUE_ENTRY_SIZE)+ISSUE_ACKSTATUS, ias.issues[ID].ackStatus);	Busy_eep();	ClrWdt();	//IAS_updateIssues(ias.issues[ID].data);	for( i = 0 ; i < MAX_ISSUES ;i++)	{		if( ias.issues[i].ackStatus == 1)			return;	}	BUZ_OP = 0;				}

void _ISR_PSV _U2RXInterrupt(void) {	// UART2 RX [6zb]    //InterruptTest6++;    __builtin_disi(0x3FFF); //disable interrupts up to priority 6 for n cycles    _U2RXIF = 0; 	// interrupt flag reset    ClrWdt();		// [1]    unsigned char DatoRx;    DatoRx = ReadUART2();    if(StatoSeriale[PORT_COM2] == WAIT_MESSAGE)    {   //  time-out dei dati in ricezione non sia scaduto, altrimenti        if (!TimerOutRxModbus[PORT_COM2])        {   FreeRxBuffer(PORT_COM2);        }        TimerOutRxModbus[PORT_COM2] = TIME_OUT_MODBUS;        *RxPointer[PORT_COM2] = DatoRx; //  Salva nel buffer il dato ricevuto        RxPointer[PORT_COM2]++;        RxNByte[PORT_COM2]++;        if (RxNByte[PORT_COM2] >= MODBUS_N_BYTE_RX)     //  se ricevuti più caratteri della lunghezza del buffer        {   RxPointer[PORT_COM2] = ModbusRxBuff[PORT_COM2]; //  azzera il puntatore di ricezione            RxNByte[PORT_COM2] = 0;                 //  e il numero di byte ricevuti        }    }    DISICNT = 0; //re-enable interrupts    //InterruptTest6--;}

/*************************************************** Function name		: void main(void)** Created by		: Luca Lucci* Date created		: 07/10/12* Description		: Main program entry point* Notes				: -**************************************************/void main(void){  initialize_system();    // initialize usart  uart_init();  uart2_open();  // initialize interrupt  INTCON2bits.INTEDG0 = 0;	// falling edge int0 interrupt  INTCONbits.INT0IE = 1;	// enable int0 interrupt  INTCONbits.INT0IF = 0;  INTCONbits.PEIE = 1;		// enable peripheral interrupts  INTCONbits.GIE = 1;		// enable global interrupt    while(1)   {    ClrWdt();        // if the buffer isn't empty will send back the data    if(uart2_buffer_read(temp))      uart2_buffer_tx_load(temp);    // ProcessIO  }}//main()

/*---------------------------------------------------------------------------------------------------------------*	BOOL update_timeouts(void)*----------------------------------------------------------------------------------------------------------------*/BOOL update_timeouts(void){	UINT8 i;	BOOL result = FALSE;	for(i = 0; i <MAX_ISSUES; i++)						//check for timeout of issues raised	{		if(ias.issues[i].state == ISSUE_RAISED)		{			if(ias.issues[i].timeout == 0)			{				ias.issues_critical++;				ias.issues_raised--;				ias.issues[i].state = ISSUE_CRITICAL;								Write_b_eep((i*ISSUE_ENTRY_SIZE)+ISSUE_STATE,ias.issues[i].state);				Busy_eep();				ClrWdt();						ias.state = ISSUE_CRITICAL;//put up				result = TRUE;			}		}	}	return result;}

void BootMain(void)#endif{    //NOTE: The c018.o file is not included in the linker script for this project.    //The C initialization code in the c018.c (comes with C18 compiler in the src directory)    //file is instead modified and included here manually.  This is done so as to provide    //a more convenient entry method into the bootloader firmware.  Ordinarily the _entry_scn    //program code section starts at 0x00 and is created by the code of c018.o.  However,    //the linker will not work if there is more than one section of code trying to occupy 0x00.    //Therefore, must not use the c018.o code, must instead manually include the useful code    //here instead.    //Make sure interrupts are disabled for this code (could still be on,    //if the application firmware jumped into the bootloader via software methods)    INTCON = 0x00;      //Initialize the C stack pointer, and other compiler managed items as     //normally done in the c018.c file (applicable when using C18 compiler)    #ifndef __XC8__        _asm            lfsr 1, _stack            lfsr 2, _stack            clrf TBLPTRU, 0        _endasm    #endif    //Clear the stack pointer, in case the user application jumped into     //bootloader mode with excessive junk on the call stack    STKPTR = 0x00;      // End of the important parts of the C initializer.  This bootloader firmware does not use    // any C initialized user variables (idata memory sections).  Therefore, the above is all    // the initialization that is required.    //Call other initialization code and (re)enable the USB module    InitializeSystem();     //Some USB, I/O pins, and other initialization        //Execute main loop    while(1)    {        ClrWdt();                //Need to call USBDeviceTasks() periodically.  This function takes care of        //processing non-USB application related USB packets (ex: "Chapter 9"         //packets associated with USB enumeration)        USBDeviceTasks();        BlinkUSBStatus();   //When enabled, blinks LEDs on the board, based on USB bus state                LowVoltageCheck();  //Regularly monitor voltage to make sure it is sufficient                            //for safe operation at full frequency and for erase/write                            //operations.                       ProcessIO();        //This is where all the actual bootloader related data transfer/self programming takes                            //place see ProcessIO() function in the BootPIC[xxxx].c file.    }//end while    }    

/* switch to ADC chan 8 (shorted to ground) to reset ADC measurement cap to zero before next measurement */void ADC_zero(void){	ClrWdt(); // reset the WDT timer	SetChanADC(ADC_CH8); // F3 grounded input	Delay10TCYx(ADC_CHAN_DELAY);	ConvertADC();	while (BusyADC());}

void DisplayBootScreen() {    byte y = 8;    char s[10];    byte x;    uint32 i;    ClrWdt();    ClearImage();    ClrWdt();    BootPrintln("OLED Watch v1.0");    //DrawString("Booting...", 8, y, WHITE); y += 10;            for (i=0; i<1000000; i++) { ClrWdt(); }}

int main() {	DWORD t = 0;	//Needed because a bug in picc-18?	MIWRL=0;	MIWRH=0;	TRISA = 0;	TRISB = 0;	TRISC = 0;	TRISD = 0;	TRISE = 0;	TRISF = 0;	TRISG = 0;	PORTA=0;	PORTB=0;	PORTC=0;	PORTD=0;	PORTE=0;	PORTF=0;	OSCTUNE = 0x40; //Speed up to 41.67 MHz	//Turn off AD	ADCON1 = 0x0F;#if defined(DEBUG) && defined(_18F87J60)	initUsart2();#endif	initTransmitter();	initReceiver();	initPwm();	initInterrupts();	initAppConfig();	initWDT();	TickInit();	StackInit();	//Set the LED on the connector	SetLEDConfig(0x3742); //See MAC.h for the values	printf("Telldus TellStick Net v%s/r/n", FIRMWARE_VERSION);	while(1) {		StackTask();		StackApplications();		if(TickGet() - t >= TICK_SECOND) {			t = TickGet();		}#if defined(DEBUG)		debugTask();#endif		rfReceiveTask();		discoveryTask();		ClrWdt();	}	return 42;}

void dumpHandler(){u8 ii;		isError = 1;			switch(test_pos_now)			{				case TEST_CHANNEL_1:						OPEN_CHANNEL_1();LED1_R_ON();break;				case TEST_CHANNEL_2:						OPEN_CHANNEL_2();LED2_R_ON();break;				case TEST_CHANNEL_3:						OPEN_CHANNEL_3();LED3_R_ON();break;				case TEST_CHANNEL_4:						OPEN_CHANNEL_4();LED4_R_ON();break;				default:						dumpHandler();break;			}				return;				for(ii=0; ii <= 3; ii++)				{					if(stepNow & (1<<ii))						LED_ON(ii);					else						LED_OFF(ii);				}				while(1)				{					NOP();					ClrWdt();				}	LED1_R_ON();	LED2_R_ON();	LED3_R_ON();	LED4_R_ON();	while(1)	{		NOP();		ClrWdt();	}}

void delay_ms(u16 nus){    unsigned int i , j;    for(i=0;i<nus;i++)   {   	ClrWdt();	for(j=0;j<1000;j++);    }}

void lcd_send_byte( unsigned char address, unsigned char n ) {   PIN_LCD_RS = 0;   LCD_DELAY();   PIN_LCD_RS = address;   ClrWdt();   PIN_LCD_E = 0;   lcd_send_nibble(n >> 4);   lcd_send_nibble(n & 0xf);}

/*----------------------------------------------Store department riase vlaue to EEPROM------------------------------------------------*/void writeDeptRaise(void){	UINT8 i;	for( i = 0; i < MAX_DEPARTMENTS ;i++)	{		Write_b_eep(DEPARTMENT_RAISE_ADD + i ,ias.department_raised[i+1] );		Busy_eep();		ClrWdt();	}}

void U1SetBaudrate(uint32_t baudrate) {    while (!U1TxReady()) ClrWdt(); // wait for buffer to flush    TXSTA1bits.SYNC = 0;    // Asynchronous    TXSTA1bits.BRGH = 1;    // High speed    BAUDCONbits.BRG16 = 1; // 16-Bit Baud Rate Register    uint16_t baud = _XTAL_FREQ / (4 * (baudrate + 1));    SPBRG = baud & 0xFF;    SPBRGH = baud >> 8;    uart1BaudSetting = baudrate;}

voidmain (){  TRISB = 0b11111001;  TRISCbits.TRISC6 = 0;  // Gobally disable IRQs  INTCONbits.GIE = 0;  // init USART peripheral  RCSTAbits.SPEN = 1;  // baud rate to 115200 Baud  SPBRG = 6;  // enable TX + high speed mode  TXSTA = 0b00100100;  // light red LED to indicate dump process  LED_RED = 0;  LED_GREEN = 1;  EEADR = 0;  EECON1bits.CFGS = 0;  EECON1bits.EEPGD = 0;  do    {      EECON1bits.RD = 1;      TXREG = EEDATA;      EEADR++;      while (!TXSTAbits.TRMT);      ClrWdt ();    }  while (EEADR);  // turn off red LED  // light green LED to indicate stopped dump process  LED_RED = 1;  LED_GREEN = 0;  // sit there idle  for (;;)    ClrWdt ();}

void APP_raiseIssues(far UINT8* data){	UINT8 i,j,issueIndex;	UINT8 *ptr;	for(i = 0; i < MAX_ISSUES; i++)										//for each issue		if(ias.issues[i].state != ISSUE_RESOLVED )						//if it is raised			if(strcmp((INT8*)data,(INT8 *)ias.issues[i].data) == 0)		//if input matches									return;												//do nothing	for( i = 0 ; i < MAX_ISSUES ;i++)	{		if( ias.issues[i].state == ISSUE_RESOLVED )		{			ias.issues[i].state = ISSUE_RAISED;			ias.issues[i].timeout =  timeout;			ias.issues[i].ackStatus = 1;			strcpy((INT8*) ias.issues[i].data, (INT8*)data);			ptr = (UINT8*)&ias.issues[i];			for(j = 0; j < ISSUE_ENTRY_SIZE; j++)			{				Write_b_eep(j+(i*ISSUE_ENTRY_SIZE),*(ptr+j));				Busy_eep();				ClrWdt();			}			ias.issues_raised++;            if(ias.issues_critical == 0)            {				if(	ias.mutualAid == 1 )				  	updateIndication(-1,1,0,0);				else							  		updateIndication(0,1,0,0);            }            else            {				if( ias.mutualAid == 1)			  		updateIndication(-1,1,1,0);				else					updateIndication(0,1,1,0);			}			updateLog(data);			break;		}	}	if( ias.issues_critical ==  0 )		ias.state = ISSUE_RAISED;}

/*----------------------------------------------Store department riase vlaue from EEPROM------------------------------------------------*/void readDeptRaise(void){	UINT8 i;	for( i = 0; i < MAX_DEPARTMENTS ;i++)	{		ias.department_raised[i+1] = Read_b_eep( DEPARTMENT_RAISE_ADD + i );		Busy_eep();		ClrWdt();	}}

void IoWait(unsigned int Micros) { int micros;// Pre : Micros és positiu// Post: Espera el nombre de microsegons especificat. NO ES COOPERATIVA// i per tant s'ha d'usar amb molta precaució. Esta afinada per a un clock de 8M	micros=Micros>>1;	while(micros!=0) {                         		ClrWdt();		--micros; 		Nop(); Nop(); Nop();	}}

void vApplicationIdleHook(void){    /*     * **configUSE_IDLE_HOOK must be set to 1**     * Esta funcion se ejecuta cuando el procesador     * no esta siendo utilizado por otra tarea     */    ClrWdt();    Idle();}

void U2SetBaudrate(uint32_t baudrate) {    while (!U2TxReady()) ClrWdt(); // wait for buffer to flush    TXSTA2bits.SYNC = 0;    // Asynchronous    TXSTA2bits.BRGH = 1;    // High speed    BAUDCON2bits.BRG16 = 1; // 16-Bit Baud Rate Register    uint16_t baud = _XTAL_FREQ / (4 * (baudrate + 1));    SPBRG2 = baud & 0xFF;    // SPBRG 416 --> baud 38400    SPBRGH2 = baud >> 8;     // SPRGB 138 --> baud 115200    uart2BaudSetting = baudrate;}

byte DTMFGetBin(DTMFDriver *me){	byte HexDigit = me_data &= me_mask;		/* Leer dato desde el puerto */	/*************/		PortEnable8870(me);						/* Tomar bus */	while (me_std && !me_hook)				/* Esperar key release */		ClrWdt();		return HexDigit;}//

void high_isr(void){	ClrWdt();	#ifdef USE_CAN		canISR();	#endif	tickUpdate();}