BOOL EEPROMCommand(UINT8 command, UINT16 volatile * const address, const UINT16 data) { if (ECLKDIV_EDIVLD && EEPROM_ValidateAddress((void * const)address)) { /* clear PVIOL and ACCERR flags */ ESTAT = ESTAT_PVIOL_MASK | ESTAT_ACCERR_MASK; while(!ESTAT_CBEIF) { /* feed watch dog */ __RESET_WATCHDOG(); } EEPROM_WORD(address) = data; ECMD = command; ESTAT = ESTAT_CBEIF_MASK; if (!ESTAT_PVIOL && !ESTAT_ACCERR) { while(!ESTAT_CCIF) { /* feed watchdog */ __RESET_WATCHDOG(); } return bTRUE; } } return bFALSE; }
/****************************************************************************** * Function: void USB_Remote_Wakeup(void) * Input: None * Output: None * Overview: This function is used to send wake-up signal from device to * host or hub * * Note: According to USB 2.0 specification section 7.1.7.7, * "The remote wakeup device must hold the resume signaling * for at lest 1 ms but for no more than 15 ms." *****************************************************************************/ void USB_Remote_Wakeup(void) { static word delay_count; /*delay to make sure the remote wakeup is generated after 5ms idle*/ delay_count = 2000; do { delay_count--; __RESET_WATCHDOG(); }while(delay_count); USB_WakeFrom_Suspend(); CTL_CRESUME = 1; /* Start RESUME signaling*/ delay_count = 5000; /* Set RESUME line for 1-15 ms*/ do { delay_count--; __RESET_WATCHDOG(); }while(delay_count); CTL_CRESUME = 0; }
void main(void) { unsigned char count = 0; GPIO_ConfigPinDirection(PORTA,1,INPUT); while(!GPIO_ReadPin(PORTA,1)) { __RESET_WATCHDOG(); } EnableInterrupts; /* include your code here */ //Para el serial SCIBD = 26; SCIC2 = 0x0C; //Para el ADC //APCTL1 = 0x01; //Este si //ADCCFG = 0xA0; //ADCSC1 = 0x40; //Este si count = 0; voltage[3] = 0x31; voltage[2] = 0x31; voltage[0] = 0x31; do { do { __RESET_WATCHDOG(); } while(!SCIS1_TC); SCID = voltage[count]; count++; } while(count<5); for(;;) { __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
/********************************************************* * Name: SPI_Send_byte * Desc: Send one byte * Parameter: The byte to be sent * Return: None **********************************************************/ void SPI_Send_byte(uint_8 u8Data) { while(!SPI1S_SPTEF) { __RESET_WATCHDOG(); } (void)SPI1S; SPI1DL=u8Data; while(!SPI1S_SPRF) { __RESET_WATCHDOG(); } (void)SPI1DL; }
void System_Time(void) { // task setup INT8U i = 0; INT8U cnt = 0; OSResetTime(); // task main loop for (;;) { #if (WATCHDOG == 1) __RESET_WATCHDOG(); #endif DelayTask(10); i++; VerifyNeighbourhoodLastIDTimeout(); if (i >= 100) { OSUpdateUptime(); i = 0; } } }
/****************************************************************************** * Function: unsigned char USB_WakeUp() * Input: * Output: 0: noise, re-entern into sleep * 1: Bus wake-up * 2: remote wake up * Overview: The USB sleep and wake up * Note: None *****************************************************************************/ unsigned char USB_WakeUp(void ) { int delay_count; USBCTL0_USBRESMEN = 1; asm STOP; /*MCU enter into stop3*/ if(Usb_State_Flag & WAKE_UP_BY_RESET) { //Usb_Device_State = DEFAULT_STATE; Usb_State_Flag &= (~WAKE_UP_BY_RESET); return 3; } /*add delay to filter the noise */ if(USBCTL0_LPRESF) USBCTL0_USBRESMEN =0 ; delay_count = 50; do { delay_count--; __RESET_WATCHDOG(); }while(delay_count); if(INTSTAT_RESUMEF) /*The resume signal has engouh time to set RESUMEF bit*/ { return 1; /*USB resume*/ } else return 0; /*resume is caused by noise*/ }
void SD_Write_Block(PTR_LBA_APP_STRUCT lba_data_ptr) { /* Body */ uint_32 u32Counter; SPI_set_SS(); gu8SD_Argument.lword = lba_data_ptr->offset; if(SD_SendCommand(SD_CMD24|0x40,SD_OK)) { SPI_clr_SS() ; return; /* Command IDLE fail */ } /* EndIf */ SPI_Send_byte(0xFE); for(u32Counter=0;u32Counter<lba_data_ptr->size;u32Counter++) { SPI_Send_byte(*(lba_data_ptr->buff_ptr + u32Counter)); } /* EndFor */ SPI_Send_byte(0xFF); /* checksum Bytes not needed */ SPI_Send_byte(0xFF); if((SPI_Receive_byte() & 0x0F) != 0x05) { SPI_clr_SS() ; return; /* Command fail */ } /* EndIf */ while(SPI_Receive_byte()==0x00) { __RESET_WATCHDOG(); /* Dummy SPI cycle */ } /* EndWhile */ SPI_clr_SS() ; return; } /* EndBody */
void _Entry(void) { /* Check if bootloader flasher is enable */ #if (defined BOOTLOADER_ENABLE) && (BOOTLOADER_ENABLE == 1) #include "MCF51_Bootloader.h" unsigned int status_prog; /* check flag status (@STATUS_ADDR address) which indicate where to go: bootloader mode or application (main) mode */ status_prog = *(dword *) STATUS_ADDR; __RESET_WATCHDOG(); // decide which mode to go: user code or bootloader if(status_prog != BOOTLOADER_ENTER_FLAG) { asm (JMP MAIN_ENTRY_POINT); // jump to user entry } else {
void System_Time(void) { // task setup INT16U i = 0; OSResetTime(); Init_Calendar(); // task main loop for (;;) { #if (WATCHDOG == 1) __RESET_WATCHDOG(); #endif DelayTask(10); i++; if (i >= 100) { i = 0; OSUpdateUptime(); OSUpdateCalendar(); } } }
//Programa que envia valor de ADC por serial interrupt 19 void AdcISR(void) { unsigned char count = 0; unsigned int Adc; ADCSC1 = 0x20; Adc = (unsigned int)ADCRL; //Al leer, se apaga la bandera Adc = (Adc*13); Adc /= 10; voltage[3] = (Adc%10) + 0x30; Adc /= 10; voltage[2] = (Adc%10) + 0x30; voltage[0] = (Adc/10) + 0x30; do { do { __RESET_WATCHDOG(); } while(!SCIS1_TDRE); SCID = voltage[count]; count++; /*while(!GPIO_ReadPin(PORTA,1)) { __RESET_WATCHDOG(); }*/ } while(count<5); ADCSC1 = 0x20; }
UINT8 SD_ReadSector(UINT32 u32SD_Block,UINT8 pu8DataPointer[]) { volatile UINT8 u8Temp = 0; __RESET_WATCHDOG(); /* feeds the dog */ if (!gSDCard.SDHC) u32SD_Block <<= SD_BLOCK_SHIFT; SPI_SS = ENABLE; //Utilizo u8Temp para capturar respuesta de la tarjeta SD (fines depurativos) u8Temp = SD_SendCommand(SD_CMD17_READ_BLOCK, u32SD_Block, NULL, 0); if((u8Temp & SD_R1_ERROR_MASK) != SD_OK) { SPI_SS = DISABLE; return (SD_FAIL_READ); } while(u8Temp != 0xFE) u8Temp = SPI_ReceiveByte(); //La SD responde 0xFF...0xFF mientras accede al sector y 0xFE cuando esta lista. //Los datos que envía a continuación corresponden al sector solicitado. if (SD_ReadData(pu8DataPointer,SD_BLOCK_SIZE) != SD_OK) return (SD_FAIL_READ); SPI_SS = DISABLE; return (SD_OK); }
void main(void) { EnableInterrupts; SerialManager_Init(); Bootloader_FlashErase(address); /* include your code here */ for(;;) { SerialManager_GetValue(&u8new_data, &data_byte, &u8complete_data, &finish_write); __RESET_WATCHDOG(); /* feeds the dog */ if((u8new_data == 1) && (u8complete_data==1)) { FCDIV = u8mask_write; if(TRUE){ u8error=Bootloader_FlashWrite(address,&data_byte,1); address++; } } if(finish_write) { __asm{ JMP address; } } } /* loop forever */ /* please make sure that you never leave main */ }
/********************************************************* * Name: SPI_Send_byte * Desc: Send one byte * Parameter: The byte to be sent * Return: None **********************************************************/ void SPI_Send_byte(uint_8 u8Data) { if (SPI_SS) SPI_SS &= ~ENABLE; while(!(SPI0_S & SPI_S_SPTEF_MASK)) { __RESET_WATCHDOG(); } (void)SPI0_S; SPI0_DL=u8Data; while(!(SPI0_S & SPI_S_SPRF_MASK)) { __RESET_WATCHDOG(); } (void)SPI0_DL; }
/********************************************************* * Name: SPI_Receive_byte * Desc: The byte received by SPI * Parameter: None * Return: Received byte **********************************************************/ uint_8 SPI_Receive_byte(void) { SPI0_DL = 0xFF; while(!(SPI0_S & SPI_S_SPRF_MASK)) { __RESET_WATCHDOG(); } return(SPI0_DL); }
void main(void) { USB_STATUS status = USB_OK; /* Initialize the current platform. Call for the _bsp_platform_init which is specific to each processor family */ _bsp_platform_init(); sci1_init(); sci2_init(); IIC_ModuleInit(); TimerInit(); DisableInterrupts; /* enable interrupt OTG module */ Int_Ctl_int_init(IRQ3_INT_CNTL, IRQ3_ISR_SRC, 2,2, TRUE); MCF_EPORT_EPPAR |= MCF_EPORT_EPPAR_EPPA3_FALLING; /* falling edge */ MCF_EPORT_EPDDR &= ~MCF_EPORT_EPDDR_EPDD3; /* set input*/ MCF_EPORT_EPIER |= MCF_EPORT_EPIER_EPIE3; /* enable interrupts IRQ 3 */ /* set VHost pin ( PUC3) */ MCF_GPIO_DDRUC |= MCF_GPIO_DDRUC_DDRUC3; /* set output */ MCF_GPIO_PUCPAR |= MCF_GPIO_PUCPAR_UCTS2_GPIO; /* set as GPIO */ ENABLE_USB_5V; status = _usb_otg_init(0, (OTG_INIT_STRUCT*)&otg_init, &otg_handle); if(status == USB_OK) { status = _usb_otg_register_callback(otg_handle, App_OtgCallback); } EnableInterrupts; #if (defined _MCF51MM256_H) || (defined _MCF51JE256_H) usb_int_en(); #endif printf("\n\rInitialization passed. Plug-in MSD device to USB port"); printf("\n\rPress P to print the menu:"); for(;;) { _usb_otg_task(); if(dev_stack_active) { App_PeripheralTask(); } if(host_stack_active) { App_Host_Task(); } App_HandleUserInput(); __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
void main(void) { EnableInterrupts; /* include your code here */ for(;;) { __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
/** * Execute Flash command at runtime: must run at another FLASH block * that is being modified. Usually from RAM * @param flash address to modify * @param flash number of longwords to modify * @param flash data pointer * @param flash command * @return none */ __relocate_code__ uint8 /*far*/ Flash_Cmd(uint32 FlashAddress, uint16 FlashDataCounter, uint32 *pFlashDataPtr, uint8 FlashCommand) { /* Check to see if FACCERR or PVIOL is set */ if (FSTAT&0x30) { /* Clear Flags if set*/ FSTAT = 0x30; } if (FlashDataCounter) { do { /* Wait for the Last Busrt Command to complete */ while(!(FSTAT&FSTAT_FCBEF_MASK)) { __RESET_WATCHDOG(); /* feeds the dog */ }/*wait until termination*/ /* Write Data into Flash*/ (*((volatile unsigned long *)(FlashAddress))) = *pFlashDataPtr; FlashAddress += 4; pFlashDataPtr++; /* Write Command */ FCMD = FlashCommand; /* Put FCBEF at 1 */ FSTAT = FSTAT_FCBEF_MASK; asm(nop); asm(nop); asm(nop); asm(nop); /* Check if Flash Access Error or Protection Violation Error are Set */ if (FSTAT&0x30) { /* If so, finish the function returning 1 to indicate error */ return (1); } }while (--FlashDataCounter); } /* wait for the last command to complete */ while ((FSTAT&FSTAT_FCCF_MASK)==0) ;/*wait until termination*/ /* Return zero to indicate that the function executed OK */ return (0); }
/********************************************************* * Name: SPI_Receive_byte * Desc: The byte received by SPI * Parameter: None * Return: Received byte **********************************************************/ uint_8 SPI_Receive_byte(void) { SPI1DL=0xFF; while(!SPI1S_SPRF) { __RESET_WATCHDOG(); } return(SPI1DL); }
void main(void) { KeyboardManager_Init(); EnableInterrupts; for(;;) { __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
char TERMIO_GetChar() { int ch; do { __RESET_WATCHDOG(); ch = xbee_ser_getchar( &HOST_SERIAL_PORT); } while (ch < 0); return (char) ch; }
/** * main program */ void main(void) { EnableInterrupts; // Interrupts aktivieren for(;;) { __RESET_WATCHDOG(); /* feeds the dog */ } /* please make sure that you never leave main */ }
void main(void) #endif { USB_STATUS status = USB_OK; /* Initialize the current platform. Call for the _bsp_platform_init which is specific to each processor family */ _bsp_platform_init(); #ifdef MCU_MK70F12 sci2_init(); #else sci1_init(); #endif TimerInit(); /* Init polling global variable */ POLL_init(); DisableInterrupts; status = _usb_host_init(HOST_CONTROLLER_NUMBER, /* Use value in header file */ MAX_FRAME_SIZE, /* Frame size per USB spec */ &host_handle); /* Returned pointer */ if(status != USB_OK) { printf("\nUSB Host Initialization failed! STATUS: 0x%x",(unsigned int) status); fflush(stdout); exit(1); } /* ** Since we are going to act as the host driver, register the driver ** information for wanted class/subclass/protocols */ status = _usb_host_driver_info_register(host_handle, (void *)DriverInfoTable); if(status != USB_OK) { printf("\nUSB Initialization driver info failed! STATUS: 0x%x", status); fflush(stdout); exit(1); } EnableInterrupts; printf("\nUSB Printer Host Demo\nWaiting for USB printer to be attached...\n"); fflush(stdout); for(;;) { Poll(); Printer_Task(NULL); __RESET_WATCHDOG(); /* feeds the dog */ } /* Loop forever */ /* Please make sure that you never leave main */ #ifdef __GNUC__ return 0; #endif }
void main(void) { unsigned int u16RpmSpeed; char u8RpmSpeed; unsigned int u16adcVoltage; char u8adcVoltage; EnableInterrupts; SpeedManager_Init(); DelayManager_Init(); StepperMotor_Init(); LcdManager_Init(); sgu8OldSpeedLevel = 0; (void)DelayManager_SetDelayBySpeed(0); DelayManager_Delay(); for(;;){ sgu8SpeedLevel = SpeedManager_ReadSpeedLevel(&sgu8AdcValue); if(DelayManager_IsBusy() == 0) { StepperMotor_NextStep(); sgu8Dir = StepperMotor_RefreshDirection(); (void)DelayManager_SetDelayBySpeed(sgu8SpeedLevel); DelayManager_Delay(); } LcdManager_UpdateTask(); if((sgu8SpeedLevel != sgu8OldSpeedLevel) && (LcdManager_IsBusy() == 0)) { //RPM Speed u16RpmSpeed = ((sgu8SpeedLevel+1)*11)+1; sgpu8_3bitLcdMsg[0] = (char)(u16RpmSpeed/100) + 0x30; u8RpmSpeed = (u16RpmSpeed%100); sgpu8_3bitLcdMsg[1] = u8RpmSpeed/10 + 0x30; sgpu8_3bitLcdMsg[2] = u8RpmSpeed%10 + 0x30; LcdManager_WriteString(1,0,sgpu8_3bitLcdMsg,3); //ADC value /*u16adcVoltage = ((129*sgu8AdcValue)/100); sgpu8_3bitLcdMsg[0] = (u16adcVoltage/100) + 0x30; u8adcVoltage = (u16adcVoltage%100); sgpu8_3bitLcdMsg[1] = u8adcVoltage/10 + 0x30; sgpu8_3bitLcdMsg[2] = u8adcVoltage%10 + 0x30; LcdManager_WriteString(1,4,sgpu8_3bitLcdMsg,3);*/ sgu8OldSpeedLevel = sgu8SpeedLevel; } __RESET_WATCHDOG(); } }
void SerialReset(INT8U Comm) { INT8U reset1 = 0; INT8U reset2 = 0; reset1 = SRS / 100; putcharSer(Comm, reset1 + '0'); reset2 = ((SRS - reset1 * 100) / 10); putcharSer(Comm, reset2 + '0'); reset1 = ((SRS - reset1 * 100 - reset2 * 10) % 10); putcharSer(Comm, reset1 + '0'); putcharSer(Comm, LF); putcharSer(Comm, CR); __RESET_WATCHDOG(); }
void main(void) #endif { /* Initialize the current platform. Call for the _bsp_platform_init which is specific to each processor family */ _bsp_platform_init(); #ifdef MCU_MK70F12 sci2_init(); #else sci1_init(); #endif TimerInit(); /* Init polling global variable */ POLL_init(); /* event for USB callback signaling */ _usb_event_init(&USB_Event); DisableInterrupts; #if (defined _MCF51MM256_H) || (defined _MCF51JE256_H) usb_int_dis(); #endif ApplicationInit(); EnableInterrupts; #if (defined _MCF51MM256_H) || (defined _MCF51JE256_H) usb_int_en(); #endif fflush(stdout); /* ** Infinite loop, waiting for events requiring action */ for(;;) { Poll(); Main_App_Task(); __RESET_WATCHDOG(); /* feeds the dog */ } #ifdef __GNUC__ return 0; #endif }
void main(void) { unsigned char counter; EnableInterrupts; MCU_init(); /* include your code here */ //3. Disable interrupts to permit execution of the code DisableInterrupts; //4. Cycle that writes a byte form value 0 to 127 Erase(0x3200); for(counter=0;counter<=127;counter++) { Program(0x3200 + counter, counter); } for(;;) { __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
void main(void) { /* include your code here */ // Disable COP SOPT1_COPT = 0b00; board_init(); // initialise multi-purpose clock generator led_init(); // initialise led pin settings //relay_init(); //sci_init(); seos_tpm_init(); //relay_on(); EnableInterrupts; for (;;) { __RESET_WATCHDOG(); // feeds the dog seos_goto_sleep(); } /* loop forever */ /* please make sure that you never leave main */ }
void main(void) { unsigned char state = 0; unsigned char cuenta = 0; EnableInterrupts; /* include your code here */ for(;;) { state = 0; while(cuenta < 250) { cuenta++; } state = 1; cuenta = 0; while(cuenta < 250) { cuenta++; } __RESET_WATCHDOG(); /* feeds the dog */ } /* loop forever */ /* please make sure that you never leave main */ }
uint_8 SD_Init(void) { /* Body */ SPI_Init(); /* SPI Initialization */ SPI_set_SS(); SD_CLKDelay(10); /* Send 80 clocks */ SPI_clr_SS() ; gu8SD_Argument.lword = 0; SD_CLKDelay(8); /* IDLE Command */ SPI_set_SS(); if(SD_SendCommand(SD_CMD0|0x40,SD_IDLE)) { SPI_clr_SS() ; return(1); /* Command IDLE fail */ } /* EndIf */ SPI_clr_SS() ; (void)SPI_Receive_byte(); /* Dummy SPI cycle */ /* Initialize SD Command */ SPI_set_SS(); while(SD_SendCommand(SD_CMD1|0x40,SD_OK)) { __RESET_WATCHDOG(); } /* EndWhile */ SPI_clr_SS() ; (void)SPI_Receive_byte(); /* Dummy SPI cycle */ /* Block Length */ SPI_set_SS(); gu8SD_Argument.lword = SD_BLOCK_SIZE; if(SD_SendCommand(SD_CMD16|0x40,SD_OK)) { SPI_clr_SS() ; return(1); /* Command IDLE fail */ } /* EndIf */ SPI_clr_SS() ; SPI_High_rate(); SPI_Send_byte(0x00); SPI_Send_byte(0x00); return(0); } /* EndBody */
void main(void) { /* Port F Bit 1 active when error occurs */ PTFDD |= 0x01; PTFD |= 0x01; EnableInterrupts; flash_init(); copyinRAM(); /* Copy flash routine to RAM */ if (flash_erase( 0xF800)) /* Erase flash sector */ PTFD &= ~0x01; if (flash_program( 0xF800, data)) /* Program single byte*/ PTFD &= ~0x01; for( ; ; ) { __RESET_WATCHDOG(); } /* Loop always */ }