/** * @brief Configures and activates the EXT peripheral. * * @param[in] extp pointer to the @p EXTDriver object * * @notapi */ void ext_lld_start(EXTDriver *extp) { uint16_t ch; uint32_t ier = 0; const EXTConfig *config = extp->config; switch(extp->pid) { case AT91C_ID_PIOA: AIC_ConfigureIT(AT91C_ID_PIOA, SAM7_computeSMR(config->mode, config->priority), EXTIA_IRQHandler); break; #if (SAM7_PLATFORM == SAM7X128) || (SAM7_PLATFORM == SAM7X256) || \ (SAM7_PLATFORM == SAM7X512) || (SAM7_PLATFORM == SAM7A3) case AT91C_ID_PIOB: AIC_ConfigureIT(AT91C_ID_PIOB, SAM7_computeSMR(config->mode, config->priority), EXTIB_IRQHandler); break; #endif } /* Enable and Disable channels with respect to config.*/ for(ch = 0; ch < EXT_MAX_CHANNELS; ch++) { ier |= (config->channels[ch].mode & EXT_CH_MODE_EDGES_MASK & EXT_CH_MODE_ENABLED ? 1 : 0) << ch; } extp->pio->PIO_IER = ier; extp->pio->PIO_IDR = ~ier; /* Enable interrupt on corresponding PIO port in AIC.*/ AIC_EnableIT(extp->pid); }
/** * @brief Low level serial driver initialization. * * @notapi */ void sd_lld_init(void) { #if USE_SAM7_USART0 sdObjectInit(&SD1, NULL, notify1); SD1.usart = AT91C_BASE_US0; AT91C_BASE_PIOA->PIO_PDR = SAM7_USART0_RX | SAM7_USART0_TX; AT91C_BASE_PIOA->PIO_ASR = SAM7_USART0_RX | SAM7_USART0_TX; AT91C_BASE_PIOA->PIO_PPUDR = SAM7_USART0_RX | SAM7_USART0_TX; AIC_ConfigureIT(AT91C_ID_US0, AT91C_AIC_SRCTYPE_HIGH_LEVEL | SAM7_USART0_PRIORITY, USART0IrqHandler); #endif #if USE_SAM7_USART1 sdObjectInit(&SD2, NULL, notify2); SD2.usart = AT91C_BASE_US1; AT91C_BASE_PIOA->PIO_PDR = SAM7_USART1_RX | SAM7_USART1_TX; AT91C_BASE_PIOA->PIO_ASR = SAM7_USART1_RX | SAM7_USART1_TX; AT91C_BASE_PIOA->PIO_PPUDR = SAM7_USART1_RX | SAM7_USART1_TX; AIC_ConfigureIT(AT91C_ID_US1, AT91C_AIC_SRCTYPE_HIGH_LEVEL | SAM7_USART1_PRIORITY, USART1IrqHandler); #endif #if USE_SAM7_DBGU_UART sdObjectInit(&SD3, NULL, notify3); /* this is a little cheap, but OK for now since there's enough overlap between dbgu and usart register maps. it means we can reuse all the same usart interrupt handling and config that already exists.*/ SD3.usart = (AT91PS_USART)AT91C_BASE_DBGU; AT91C_BASE_PIOA->PIO_PDR = SAM7_DBGU_RX | SAM7_DBGU_TX; AT91C_BASE_PIOA->PIO_ASR = SAM7_DBGU_RX | SAM7_DBGU_TX; AT91C_BASE_PIOA->PIO_PPUDR = SAM7_DBGU_RX | SAM7_DBGU_TX; #endif }
/** * @brief Low level SPI driver initialization. * * @notapi */ void spi_lld_init(void) { #if AT91SAM7_SPI_USE_SPI0 spiObjectInit(&SPID1); SPID1.spi = AT91C_BASE_SPI0; spi_init(AT91C_BASE_SPI0); AT91C_BASE_PIOA->PIO_PDR = SPI0_MISO | SPI0_MOSI | SPI0_SCK; AT91C_BASE_PIOA->PIO_ASR = SPI0_MISO | SPI0_MOSI | SPI0_SCK; AT91C_BASE_PIOA->PIO_PPUDR = SPI0_MISO | SPI0_MOSI | SPI0_SCK; AIC_ConfigureIT(AT91C_ID_SPI0, AT91C_AIC_SRCTYPE_HIGH_LEVEL | AT91SAM7_SPI0_PRIORITY, SPI0IrqHandler); #endif #if AT91SAM7_SPI_USE_SPI1 spiObjectInit(&SPID2); SPID2.spi = AT91C_BASE_SPI1; spi_init(AT91C_BASE_SPI1); AT91C_BASE_PIOA->PIO_PDR = SPI1_MISO | SPI1_MOSI | SPI1_SCK; AT91C_BASE_PIOA->PIO_BSR = SPI1_MISO | SPI1_MOSI | SPI1_SCK; AT91C_BASE_PIOA->PIO_PPUDR = SPI1_MISO | SPI1_MOSI | SPI1_SCK; AIC_ConfigureIT(AT91C_ID_SPI1, AT91C_AIC_SRCTYPE_HIGH_LEVEL | AT91SAM7_SPI1_PRIORITY, SPI1IrqHandler); #endif }
void HAL_GPIO_Init(void) { AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOA); AIC_ConfigureIT(AT91C_ID_PIOA, AT91C_AIC_PRIOR_HIGHEST, ISR_PioA); AT91C_BASE_AIC->AIC_IECR = 1 << AT91C_ID_PIOA; #ifdef AT91SAM7X256 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOB); AIC_ConfigureIT(AT91C_ID_PIOB, AT91C_AIC_PRIOR_HIGHEST, ISR_PioB); AT91C_BASE_AIC->AIC_IECR = 1 << AT91C_ID_PIOB; #endif }
//////////////////////////////////////////////////////////////////////////////// // Konfiguracja timera PIT (serwo) //////////////////////////////////////////////////////////////////////////////// void PIT_Configure(int czas_us) { unsigned int dummy, piv; float tmp; //wy��czenie timera PIT na czas konfiguracji AT91C_BASE_PITC->PITC_PIMR = ~(AT91C_PITC_PITEN | AT91C_PITC_PITIEN); //oczekiwanie na wyzerowanie licznika (pole CPIV w rejestrze PIVR) while (AT91C_BASE_PITC->PITC_PIVR & AT91C_PITC_CPIV) ; //wyzerowanie potencjalnego ��dania przerwania dummy = AT91C_BASE_PITC->PITC_PIVR; //konfiguracja przerwania AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_PRIOR_LOWEST | AT91C_AIC_SRCTYPE_HIGH_LEVEL, SYSTEM_INTERRUPT_irq_handler); // AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_SYS, AT91C_AIC_PRIOR_LOWEST, AT91C_AIC_SRCTYPE_HIGH_LEVEL, SYSTEM_INTERRUPT_irq_handler); AIC_EnableIT(AT91C_ID_SYS); // AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_SYS); //w��czenie timera PIT i ustawienie interwa�u //piv = ( ( czas_us * ( (MCK/16)/1000 ) ) / 1000 ); tmp = ((((float) MCK) / (16000000.0)) * (float) czas_us) - 1.0; piv = tmp; AT91C_BASE_PITC->PITC_PIMR = (piv | AT91C_PITC_PITEN | AT91C_PITC_PITIEN); }
/* * Board-specific initialization code. */ void boardInit(void) { /* * LED pins setup. */ palClearPad(IOPORT1, PIOA_LED1); palSetPadMode(IOPORT1, PIOA_LED1, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(IOPORT1, PIOA_LED2); palSetPadMode(IOPORT1, PIOA_LED2, PAL_MODE_OUTPUT_PUSHPULL); /* * buttons setup. */ palSetGroupMode(IOPORT1, PIOA_B1_MASK | PIOA_B2_MASK, 0, PAL_MODE_INPUT); /* * MMC/SD slot setup. */ palSetGroupMode(IOPORT1, PIOA_MMC_WP_MASK | PIOA_MMC_CP_MASK, 0, PAL_MODE_INPUT); /* * PIT Initialization. */ AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_SRCTYPE_HIGH_LEVEL | (AT91C_AIC_PRIOR_HIGHEST - 1), SYSIrqHandler); AIC_EnableIT(AT91C_ID_SYS); AT91C_BASE_PITC->PITC_PIMR = (MCK / 16 / CH_FREQUENCY) - 1; AT91C_BASE_PITC->PITC_PIMR |= AT91C_PITC_PITEN | AT91C_PITC_PITIEN; }
//------------------------------------------------------------------------------ /// Do calibration /// \param pLcdBuffer LCD buffer to use for displaying the calibration info. /// \return 1 if calibration is Ok, 0 else //------------------------------------------------------------------------------ unsigned char TSD_Calibrate(void *pLcdBuffer) { unsigned char ret = 0; // Calibration is done only once if(TSDCom_IsCalibrationOk()) { return 1; } // Enable trigger TSADCC_SetTriggerMode(AT91C_TSADC_TRGMOD_PENDET_TRIGGER); // Do calibration ret = TSDCom_Calibrate(pLcdBuffer); // Disable trigger TSADCC_SetTriggerMode(AT91C_TSADC_TRGMOD_NO_TRIGGER); // Configure interrupt generation // Do it only if the calibration is Ok. if(ret) { TSADCC_SetTriggerMode(AT91C_TSADC_TRGMOD_PENDET_TRIGGER); AIC_ConfigureIT(AT91C_ID_TSADC, 0, InterruptHandler); AIC_EnableIT(AT91C_ID_TSADC); AT91C_BASE_TSADC->TSADC_IER = AT91C_TSADC_PENCNT; } return ret; }
void USART1_UART_Init(unsigned int baudrate) { unsigned int mode = AT91C_US_USMODE_NORMAL | AT91C_US_CLKS_CLOCK | AT91C_US_CHRL_8_BITS | AT91C_US_PAR_NONE | AT91C_US_NBSTOP_1_BIT | AT91C_US_CHMODE_NORMAL; // Configure pins PIO_Configure(pins, PIO_LISTSIZE(pins)); // Enable the peripheral clock in the PMC PMC_EnablePeripheral(AT91C_ID_US0); // Configure the USART in the desired mode USART_Configure(AT91C_BASE_US0, mode, baudrate, BOARD_MCK); // Configure the RXBUFF interrupt AT91C_BASE_US0->US_IER = AT91C_US_RXRDY; AIC_ConfigureIT(AT91C_ID_US0, 0, ISR_Usart0); AIC_EnableIT(AT91C_ID_US0); // Enable receiver & transmitter USART_SetTransmitterEnabled(AT91C_BASE_US0, 1); USART_SetReceiverEnabled(AT91C_BASE_US0, 1); }
/* Turn on interrupts for a pio channel - a, b or c at a given priority. */ void Io_initInterrupts(AT91S_PIO* pio, unsigned int priority) { unsigned int chan; void (*isr_handler)( ); if( pio == AT91C_BASE_PIOA ) { chan = AT91C_ID_PIOA; isr_handler = IoAIsr_Wrapper; Io_isrAInit = true; } else if( pio == AT91C_BASE_PIOB ) { chan = AT91C_ID_PIOB; isr_handler = IoBIsr_Wrapper; Io_isrBInit = true; } else if( pio == AT91C_BASE_PIOC ) { chan = AT91C_ID_PIOC; isr_handler = IoCIsr_Wrapper; Io_isrCInit = true; } else return; pio->PIO_ISR; // clear with a read pio->PIO_IDR = 0xFFFFFFFF; // disable all by default AIC_ConfigureIT(chan, priority, isr_handler); // set it up AT91C_BASE_AIC->AIC_IECR = 1 << chan; // enable it }
static void platform_systimer_init() { PIT_SetPIV( SYSTIMER_LIMIT ); AIC_ConfigureIT( AT91C_ID_SYS, 0, ISR_Pit ); PIT_EnableIT(); AIC_EnableIT( AT91C_ID_SYS ); PIT_Enable(); }
void platform_int_init() { unsigned i; for( i = 0; i < NUM_UART; i ++ ) { AIC_ConfigureIT( usart_int_ids[ i ], 0, phandlers[ i ] ); AIC_EnableIT( usart_int_ids[ i ] ); } }
void TimerInit() { PMC_EnablePeripheral(AT91C_ID_TC0); // enable the Timer Counter from PMC TC_Configure(AT91C_BASE_TC0, AT91C_TC_CPCTRG); // Configure TC-0 with RC compare trig. AT91C_BASE_TC0->TC_RC = 24000; // Interrupt every 0.001s TC_Start(AT91C_BASE_TC0); // start the timer AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_TC0); AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS; AIC_EnableIT(AT91C_ID_TC0); }
void timer_init() { AT91C_BASE_PITC->PITC_PIMR = AT91C_PITC_PITIEN | AT91C_PITC_PITEN | 2999; // Clear any pending interrupt AT91C_BASE_PITC->PITC_PIVR; // This is the SYSC interrupt, shared with other things we don't care about yet AIC_ConfigureIT(1, 0, timer_interrupt); AIC_EnableIT(1); }
static void prvSetupTimerInterrupt( void ) { const uint32_t ulPeriodIn_uS = ( 1.0 / ( double ) configTICK_RATE_HZ ) * port1SECOND_IN_uS; /* Setup the PIT for the required frequency. */ PIT_Init( ulPeriodIn_uS, BOARD_MCK / port1MHz_IN_Hz ); /* Setup the PIT interrupt. */ AIC_DisableIT( AT91C_ID_SYS ); AIC_ConfigureIT( AT91C_ID_SYS, AT91C_AIC_PRIOR_LOWEST, vPortTickISR ); AIC_EnableIT( AT91C_ID_SYS ); PIT_EnableIT(); }
int platform_init() { int i; // Enable the peripherals we use in the PMC PMC_EnablePeripheral( AT91C_ID_US0 ); PMC_EnablePeripheral( AT91C_ID_US1 ); PMC_EnablePeripheral( AT91C_ID_PIOA ); PMC_EnablePeripheral( AT91C_ID_PIOB ); PMC_EnablePeripheral( AT91C_ID_TC0 ); PMC_EnablePeripheral( AT91C_ID_TC1 ); PMC_EnablePeripheral( AT91C_ID_TC2 ); PMC_EnablePeripheral( AT91C_ID_PWMC ); // Configure the timers AT91C_BASE_TCB->TCB_BMR = 0x15; for( i = 0; i < 3; i ++ ) TC_Configure( ( AT91S_TC* )timer_base[ i ], AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_WAVE ); // PWM setup (only the clocks are set at this point) PWMC_ConfigureClocks( BOARD_MCK, BOARD_MCK, BOARD_MCK ); PWMC_ConfigureChannel( 0, AT91C_PWMC_CPRE_MCKA, 0, 0 ); PWMC_ConfigureChannel( 1, AT91C_PWMC_CPRE_MCKA, 0, 0 ); PWMC_ConfigureChannel( 2, AT91C_PWMC_CPRE_MCKB, 0, 0 ); PWMC_ConfigureChannel( 3, AT91C_PWMC_CPRE_MCKB, 0, 0 ); for( i = 0; i < 4; i ++ ) { PWMC_EnableChannel( i ); PWMC_EnableChannelIt( i ); } cmn_platform_init(); #if VTMR_NUM_TIMERS > 0 // Virtual timer initialization TC_Configure( AT91C_BASE_TC2, AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_WAVE | AT91C_TC_WAVESEL_UP_AUTO ); AT91C_BASE_TC2->TC_RC = ( BOARD_MCK / 1024 ) / VTMR_FREQ_HZ; AIC_DisableIT( AT91C_ID_TC2 ); AIC_ConfigureIT( AT91C_ID_TC2, 0, ISR_Tc2 ); AT91C_BASE_TC2->TC_IER = AT91C_TC_CPCS; AIC_EnableIT( AT91C_ID_TC2 ); TC_Start( AT91C_BASE_TC2 ); #endif // Initialize the system timer cmn_systimer_set_base_freq( BOARD_MCK / 16 ); cmn_systimer_set_interrupt_period_us( SYSTIMER_US_PER_INTERRUPT ); platform_systimer_init(); return PLATFORM_OK; }
/* _____GLOBAL FUNCTIONS_____________________________________________________ */ void usart0_init(void) { // Clear flag usart0_tx_finished_flag = FALSE; // Initialise ring buffers ring_buffer_init(&usart0_rx_ring_buffer, usart0_rx_buffer, USART0_RX_BUFFER_SIZE); ring_buffer_init(&usart0_tx_ring_buffer, usart0_tx_buffer, USART0_TX_BUFFER_SIZE); // Configure PIO pins for USART0 peripheral PIO_Configure(USART0_Pins, PIO_LISTSIZE(USART0_Pins)); // Disable the interrupt on the interrupt controller AIC_DisableIT(AT91C_ID_US0); // Enable USART0 clock PMC_EnablePeripheral(AT91C_ID_US0); // Disable all USART0 interrupts AT91C_BASE_US0->US_IDR = 0xFFFFFFFF; // Configure USART USART_Configure(AT91C_BASE_US0, AT91C_US_USMODE_NORMAL | AT91C_US_CLKS_CLOCK | AT91C_US_CHRL_8_BITS | AT91C_US_PAR_NONE | AT91C_US_NBSTOP_1_BIT, 115200, BOARD_MCK); USART_SetTransmitterEnabled(AT91C_BASE_US0, 1); USART_SetReceiverEnabled(AT91C_BASE_US0, 1); // Configure the AIC for USART0 interrupts AIC_ConfigureIT(AT91C_ID_US0, AT91C_AIC_PRIOR_LOWEST | AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, usart0_interrupt); // Enable the interrupt on the interrupt controller AIC_EnableIT(AT91C_ID_US0); // Enable selected USART0 interrupts AT91C_BASE_US0->US_IER = AT91C_US_RXRDY | AT91C_US_RXBRK | AT91C_US_OVRE | AT91C_US_FRAME | AT91C_US_PARE; }
unsigned long int SysTick_Config(unsigned long int ticks) { unsigned long int rate = SystemCoreClock/ticks; /* Configure timer to interrupt specified times per second */ PIT_Init(1000000/rate, SystemCoreClock/1000000); PIT_EnableIT(); PIT_Enable(); /* Configure timer interrupt */ AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, TimerISR); AIC_EnableIT(AT91C_ID_SYS); return 0; }
/* * Board-specific initialization code. */ void boardInit(void) { /* * LCD pins setup. */ palClearPad(IOPORT2, PIOB_LCD_BL); palSetPadMode(IOPORT2, PIOB_LCD_BL, PAL_MODE_OUTPUT_PUSHPULL); palSetPad(IOPORT1, PIOA_LCD_RESET); palSetPadMode(IOPORT1, PIOA_LCD_RESET, PAL_MODE_OUTPUT_PUSHPULL); /* * Joystick and buttons setup. */ palSetGroupMode(IOPORT1, PIOA_B1_MASK | PIOA_B2_MASK | PIOA_B3_MASK | PIOA_B4_MASK | PIOA_B5_MASK, 0, PAL_MODE_INPUT); palSetGroupMode(IOPORT2, PIOB_SW1_MASK | PIOB_SW2_MASK, 0, PAL_MODE_INPUT); /* * MMC/SD slot setup. */ palSetGroupMode(IOPORT2, PIOB_MMC_WP_MASK | PIOB_MMC_CP_MASK, 0, PAL_MODE_INPUT); /* * PIT Initialization. */ AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_SRCTYPE_HIGH_LEVEL | (AT91C_AIC_PRIOR_HIGHEST - 1), SYSIrqHandler); AIC_EnableIT(AT91C_ID_SYS); AT91C_BASE_PITC->PITC_PIMR = (MCK / 16 / CH_FREQUENCY) - 1; AT91C_BASE_PITC->PITC_PIMR |= AT91C_PITC_PITEN | AT91C_PITC_PITIEN; /* * RTS/CTS pins enabled for USART0 only. */ AT91C_BASE_PIOA->PIO_PDR = AT91C_PA3_RTS0 | AT91C_PA4_CTS0; AT91C_BASE_PIOA->PIO_ASR = AT91C_PIO_PA3 | AT91C_PIO_PA4; AT91C_BASE_PIOA->PIO_PPUDR = AT91C_PIO_PA3 | AT91C_PIO_PA4; }
/*---------------------------------------------------------------------------*/ void network_init(void) { Dm9161 *pDm = &gDm9161; MacAddress.addr[0] = erb(EE_MAC_ADDR+0); MacAddress.addr[1] = erb(EE_MAC_ADDR+1); MacAddress.addr[2] = erb(EE_MAC_ADDR+2); MacAddress.addr[3] = erb(EE_MAC_ADDR+3); MacAddress.addr[4] = erb(EE_MAC_ADDR+4); MacAddress.addr[5] = erb(EE_MAC_ADDR+5); // Display MAC & IP settings TRACE_INFO(" - MAC %x:%x:%x:%x:%x:%x\n\r", MacAddress.addr[0], MacAddress.addr[1], MacAddress.addr[2], MacAddress.addr[3], MacAddress.addr[4], MacAddress.addr[5]); // clear PHY power down mode PIO_Configure(emacPwrDn, 1); // Init EMAC driver structure EMAC_Init(AT91C_ID_EMAC, MacAddress.addr, EMAC_CAF_ENABLE, EMAC_NBC_DISABLE); // Setup EMAC buffers and interrupts AIC_ConfigureIT(AT91C_ID_EMAC, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, ISR_Emac); AIC_EnableIT(AT91C_ID_EMAC); // Init DM9161 driver DM9161_Init(pDm, EMAC_PHY_ADDR); // PHY initialize //if (!DM9161_InitPhy(pDm, BOARD_MCK, // emacRstPins, PIO_LISTSIZE(emacRstPins), // emacPins, PIO_LISTSIZE(emacPins))) { if (!DM9161_InitPhy(pDm, BOARD_MCK, 0, 0, emacPins, PIO_LISTSIZE(emacPins))) { TRACE_INFO("P: PHY Initialize ERROR!\n\r"); return; } }
/* * Board-specific initialization code. */ void boardInit(void) { /* * PIT Initialization. */ AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_SRCTYPE_HIGH_LEVEL | (AT91C_AIC_PRIOR_HIGHEST - 1), SYSIrqHandler); AIC_EnableIT(AT91C_ID_SYS); AT91C_BASE_PITC->PITC_PIMR = (MCK / 16 / CH_FREQUENCY) - 1; AT91C_BASE_PITC->PITC_PIMR |= AT91C_PITC_PITEN | AT91C_PITC_PITIEN; /* * RTS/CTS pins enabled for USART0 only. */ AT91C_BASE_PIOA->PIO_PDR = AT91C_PA3_RTS0 | AT91C_PA4_CTS0; AT91C_BASE_PIOA->PIO_ASR = AT91C_PIO_PA3 | AT91C_PIO_PA4; AT91C_BASE_PIOA->PIO_PPUDR = AT91C_PIO_PA3 | AT91C_PIO_PA4; }
/** * @brief Low level I2C driver initialization. * * @notapi */ void i2c_lld_init(void) { #if SAM7_I2C_USE_I2C1 i2cObjectInit(&I2CD1); I2CD1.thread = NULL; I2CD1.txbuf = NULL; I2CD1.rxbuf = NULL; I2CD1.txbytes = 0; I2CD1.rxbytes = 0; AT91C_BASE_PIOA->PIO_PDR = AT91C_PA0_TWD | AT91C_PA1_TWCK; AT91C_BASE_PIOA->PIO_ASR = AT91C_PA0_TWD | AT91C_PA1_TWCK; AT91C_BASE_PIOA->PIO_MDER = AT91C_PA0_TWD | AT91C_PA1_TWCK; AT91C_BASE_PIOA->PIO_PPUDR = AT91C_PA0_TWD | AT91C_PA1_TWCK; AIC_ConfigureIT(AT91C_ID_TWI, AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL, TWI_IRQHandler); #endif /* STM32_I2C_USE_I2C1 */ }
void PitInit(unsigned int msperiod) { PIT_DisableIT(); // Initialize the PIT to the desired frequency PIT_Init(0, 0); // PIT timer runs at MCK/16 // calculates the PIT Value accurate to a Millisecond interrupt // msperiod can not be larget than 349 because PIV is at a 20bit limit if(msperiod > 349) msperiod = 349; PIT_SetPIV((MCK/(16*1000))*msperiod); // Configure interrupt on PIT AIC_DisableIT(AT91C_ID_SYS); AIC_ConfigureIT(AT91C_ID_SYS, AT91C_AIC_PRIOR_LOWEST, ISR_Pit); AIC_EnableIT(AT91C_ID_SYS); PIT_EnableIT(); // Enable the pit PIT_Enable(); }
//------------------------------------------------------------------------------ /// Configures the PIT to generate 1ms ticks. //------------------------------------------------------------------------------ static void ConfigurePit(void) { // Initialize and enable the PIT PIT_Init(PIT_PERIOD, BOARD_MCK / 1000000); // Disable the interrupt on the interrupt controller AIC_DisableIT(AT91C_ID_SYS); // Configure the AIC for PIT interrupts AIC_ConfigureIT(AT91C_ID_SYS, 0, ISR_Pit); // Enable the interrupt on the interrupt controller AIC_EnableIT(AT91C_ID_SYS); // Enable the interrupt on the pit PIT_EnableIT(); // Enable the pit PIT_Enable(); }
/* * See the serial2.h header file. */ xComPortHandle xSerialPortInitMinimal( unsigned long ulWantedBaud, unsigned portBASE_TYPE uxQueueLength ) { xComPortHandle xReturn = serHANDLE; /* Create the queues used to hold Rx and Tx characters. */ xRxedChars = xQueueCreate( uxQueueLength, ( unsigned portBASE_TYPE ) sizeof( signed char ) ); xCharsForTx = xQueueCreate( uxQueueLength + 1, ( unsigned portBASE_TYPE ) sizeof( signed char ) ); /* If the queues were created correctly then setup the serial port hardware. */ if( ( xRxedChars != serINVALID_QUEUE ) && ( xCharsForTx != serINVALID_QUEUE ) ) { PMC_EnablePeripheral( AT91C_ID_US0 ); portENTER_CRITICAL(); { USART_Configure( serCOM0, ( AT91C_US_CHRL_8_BITS | AT91C_US_PAR_NONE ), ulWantedBaud, configCPU_CLOCK_HZ ); /* Enable Rx and Tx. */ USART_SetTransmitterEnabled( serCOM0, pdTRUE ); USART_SetReceiverEnabled( serCOM0, pdTRUE ); /* Enable the Rx interrupts. The Tx interrupts are not enabled until there are characters to be transmitted. */ serCOM0->US_IER = AT91C_US_RXRDY; /* Enable the interrupts in the AIC. */ AIC_ConfigureIT( AT91C_ID_US0, AT91C_AIC_PRIOR_LOWEST, ( void (*)( void ) ) vSerialISR ); AIC_EnableIT( AT91C_ID_US0 ); } portEXIT_CRITICAL(); } else { xReturn = ( xComPortHandle ) 0; } /* This demo file only supports a single port but we have to return something to comply with the standard demo header file. */ return xReturn; }
//------------------------------------------------------------------------------ /// Invoked after the USB driver has been initialized. By default, configures /// the UDP/UDPHS interrupt. //------------------------------------------------------------------------------ void USBDCallbacks_Initialized(void) { #if defined(BOARD_USB_UDP) // Configure and enable the UDP interrupt // AIC_ConfigureIT(AT91C_ID_UDP, 0, UsbIsr_Wrapper); AT91C_BASE_AIC->AIC_IDCR = 1 << AT91C_ID_UDP; // Configure mode and handler AT91C_BASE_AIC->AIC_SMR[AT91C_ID_UDP] = AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | 3; AT91C_BASE_AIC->AIC_SVR[AT91C_ID_UDP] = (unsigned int) UsbIsr_Wrapper; // Clear interrupt AT91C_BASE_AIC->AIC_ICCR = 1 << AT91C_ID_UDP; // AIC_EnableIT(AT91C_ID_UDP); AT91C_BASE_AIC->AIC_IECR = 1 << AT91C_ID_UDP; #elif defined(BOARD_USB_UDPHS) // Configure and enable the UDPHS interrupt AIC_ConfigureIT(AT91C_ID_UDPHS, 0, UsbIsr_Wrapper); AIC_EnableIT(AT91C_ID_UDPHS); #else #error Unsupported controller. #endif }
void tx_init(void) { #ifdef ARM AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOA); #ifdef CUBE AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOB); #endif //CC1100_OUT_PIN CC1100_OUT_BASE->PIO_PPUER = _BV(CC1100_OUT_PIN); //Enable pullup CC1100_OUT_BASE->PIO_OER = _BV(CC1100_OUT_PIN); //Enable output CC1100_OUT_BASE->PIO_CODR = _BV(CC1100_OUT_PIN); //Clear_Bit CC1100_OUT_BASE->PIO_PER = _BV(CC1100_OUT_PIN); //Enable PIO control //CC1100_IN_PIN CC1100_IN_BASE->PIO_IER = _BV(CC1100_IN_PIN); //Enable input change interrupt CC1100_IN_BASE->PIO_ODR = _BV(CC1100_IN_PIN); //Enable input CC1100_IN_BASE->PIO_PER = _BV(CC1100_IN_PIN); //Enable PIO control AIC_ConfigureIT(CC1100_IN_PIO_ID, AT91C_AIC_PRIOR_HIGHEST, ISR_Pio); #else SET_BIT ( CC1100_OUT_DDR, CC1100_OUT_PIN); CLEAR_BIT( CC1100_OUT_PORT, CC1100_OUT_PIN); CLEAR_BIT( CC1100_IN_DDR, CC1100_IN_PIN); SET_BIT( CC1100_EICR, CC1100_ISC); // Any edge of INTx generates an int. #endif credit_10ms = MAX_CREDIT/2; for(int i = 1; i < RCV_BUCKETS; i ++) bucket_array[i].state = STATE_RESET; cc_on = 0; }
//------------------------------------------------------------------------------ /// Initializes drivers and start the USB <-> Serial bridge. //------------------------------------------------------------------------------ int main() { TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK); TRACE_INFO("-- USB Device CDC Serial Project %s --\n\r", SOFTPACK_VERSION); TRACE_INFO("-- %s\n\r", BOARD_NAME); TRACE_INFO("-- Compiled: %s %s --\n\r", __DATE__, __TIME__); // If they are present, configure Vbus & Wake-up pins PIO_InitializeInterrupts(0); // Configure USART PIO_Configure(pins, PIO_LISTSIZE(pins)); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_US0; AT91C_BASE_US0->US_IDR = 0xFFFFFFFF; USART_Configure(AT91C_BASE_US0, USART_MODE_ASYNCHRONOUS, 115200, BOARD_MCK); USART_SetTransmitterEnabled(AT91C_BASE_US0, 1); USART_SetReceiverEnabled(AT91C_BASE_US0, 1); AIC_ConfigureIT(AT91C_ID_US0, 0, ISR_Usart0); AIC_EnableIT(AT91C_ID_US0); // Configure timer 0 AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0); AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF; AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCSTOP | AT91C_TC_CPCDIS | AT91C_TC_WAVESEL_UP_AUTO | AT91C_TC_WAVE; AT91C_BASE_TC0->TC_RC = 0x00FF; AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS; AIC_ConfigureIT(AT91C_ID_TC0, 0, ISR_Timer0); AIC_EnableIT(AT91C_ID_TC0); // BOT driver initialization CDCDSerialDriver_Initialize(); // connect if needed VBus_Configure(); // Driver loop while (1) { // Device is not configured if (USBD_GetState() < USBD_STATE_CONFIGURED) { // Connect pull-up, wait for configuration USBD_Connect(); while (USBD_GetState() < USBD_STATE_CONFIGURED); // Start receiving data on the USART usartCurrentBuffer = 0; USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[0], DATABUFFERSIZE); USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[1], DATABUFFERSIZE); AT91C_BASE_US0->US_IER = AT91C_US_ENDRX | AT91C_US_FRAME | AT91C_US_OVER; AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // Start receiving data on the USB CDCDSerialDriver_Read(usbBuffer, DATABUFFERSIZE, (TransferCallback) UsbDataReceived, 0); } if( USBState == STATE_SUSPEND ) { TRACE_DEBUG("suspend !\n\r"); LowPowerMode(); USBState = STATE_IDLE; } if( USBState == STATE_RESUME ) { // Return in normal MODE TRACE_DEBUG("resume !\n\r"); NormalPowerMode(); USBState = STATE_IDLE; } } }
//------------------------------------------------------------------------------ /// Initializes the PIO interrupt management logic. /// \param priority PIO controller interrupts priority. //------------------------------------------------------------------------------ void PIO_InitializeInterrupts(unsigned int priority) { trace_LOG(trace_DEBUG, "-D- PIO_Initialize()\n\r"); SANITY_CHECK((priority & ~AT91C_AIC_PRIOR) == 0); // Reset sources numSources = 0; #ifdef AT91C_ID_PIOA // Configure PIO interrupt sources trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOA\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOA; AT91C_BASE_PIOA->PIO_ISR; AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOA, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOA); #endif #ifdef AT91C_ID_PIOB trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOB\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOB; AT91C_BASE_PIOB->PIO_ISR; AT91C_BASE_PIOB->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOB, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOB); #endif #ifdef AT91C_ID_PIOC trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOC\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOC; AT91C_BASE_PIOC->PIO_ISR; AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOC, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOC); #endif #ifdef AT91C_ID_PIOD trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOD\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOD; AT91C_BASE_PIOC->PIO_ISR; AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOD, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOD); #endif #ifdef AT91C_ID_PIOE trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOE\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOE; AT91C_BASE_PIOC->PIO_ISR; AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOE, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOE); #endif #if defined(AT91C_ID_PIOABCD) // Treat PIOABCD interrupts #if !defined(AT91C_ID_PIOA) \ && !defined(AT91C_ID_PIOB) \ && !defined(AT91C_ID_PIOC) \ && !defined(AT91C_ID_PIOD) trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOABCD\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOABCD; AT91C_BASE_PIOA->PIO_ISR; AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOABCD, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOABCD); #endif #endif #if defined(AT91C_ID_PIOABCDE) // Treat PIOABCDE interrupts #if !defined(AT91C_ID_PIOA) \ && !defined(AT91C_ID_PIOB) \ && !defined(AT91C_ID_PIOC) \ && !defined(AT91C_ID_PIOD) \ && !defined(AT91C_ID_PIOE) trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOABCDE\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOABCDE; AT91C_BASE_PIOA->PIO_ISR; AT91C_BASE_PIOA->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOABCDE, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOABCDE); #endif #endif #if defined(AT91C_ID_PIOCDE) // Treat PIOCDE interrupts #if !defined(AT91C_ID_PIOC) \ && !defined(AT91C_ID_PIOD) \ && !defined(AT91C_ID_PIOE) trace_LOG(trace_DEBUG, "-D- PIO_Initialize: Configuring PIOC\n\r"); AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_PIOCDE; AT91C_BASE_PIOC->PIO_ISR; AT91C_BASE_PIOC->PIO_IDR = 0xFFFFFFFF; AIC_ConfigureIT(AT91C_ID_PIOCDE, priority, InterruptHandler); AIC_EnableIT(AT91C_ID_PIOCDE); #endif #endif }
//////////////////////////////////////////////////////////////////////////////// // Konfiguracja USART0 w trybie DMA (DMA tylko do nadawania) // Odbi�r danych za pomoc� przerwania //////////////////////////////////////////////////////////////////////////////// void UART0_DMA_Configure(unsigned long baudrate) { float podzielnik_float; int calkowity, ulamkowy; unsigned int mode = AT91C_US_USMODE_NORMAL | /* Normal Mode */ AT91C_US_CLKS_CLOCK | /* Clock = MCK */ AT91C_US_CHRL_8_BITS | /* 8-bit Data */ AT91C_US_PAR_NONE | /* No Parity */ AT91C_US_NBSTOP_1_BIT; /* 1 Stop Bit */ //W��czenie zegara dla UART0 PMC_EnablePeripheral(AT91C_ID_US0); // AT91F_PMC_EnablePeriphClock ( AT91C_BASE_PMC, 1 << AT91C_ID_US0 ); USART_Configure(AT91C_BASE_US0, mode, baudrate, BOARD_MCK); //wylaczenie przyjmowania przerwan AT91C_BASE_US0->US_IDR = 0xFFFFFFFF; USART_SetReceiverEnabled(AT91C_BASE_US0, 0); USART_SetTransmitterEnabled(AT91C_BASE_US0, 0); // //reset portu // AT91C_BASE_US0->US_CR = AT91C_US_RSTRX | /* Reset Receiver */ // AT91C_US_RSTTX | /* Reset Transmitter */ // AT91C_US_RXDIS | /* Receiver Disable */ // AT91C_US_TXDIS; /* Transmitter Disable */ //wylaczenie DMA PDC_Disable(AT91C_BASE_PDC_US0); // //konfiguracja USART0 // AT91C_BASE_US0->US_MR = AT91C_US_USMODE_NORMAL | /* Normal Mode */ // AT91C_US_CLKS_CLOCK | /* Clock = MCK */ // AT91C_US_CHRL_8_BITS | /* 8-bit Data */ // AT91C_US_PAR_NONE | /* No Parity */ // AT91C_US_NBSTOP_1_BIT; /* 1 Stop Bit */ //predkosc //AT91C_BASE_US0->US_BRGR = (MCK/16/baudrate); //wyliczenie podzielnikow zegara MCLK podzielnik_float = ((float) MCK / 16.0 / (float) baudrate); calkowity = podzielnik_float; podzielnik_float = (podzielnik_float - calkowity) * 8; ulamkowy = podzielnik_float; AT91C_BASE_US0->US_BRGR = (calkowity) | (ulamkowy << 16); /* podzielnik calkowity + podzielnik ulamkowy */ //konfiguracja przerwania AIC_ConfigureIT(AT91C_ID_US0, 0x3 | AT91C_AIC_SRCTYPE_HIGH_LEVEL, UART0_DMA_irq_handler); // AT91F_AIC_ConfigureIt ( AT91C_BASE_AIC, AT91C_ID_US0, 0x3, AT91C_AIC_SRCTYPE_HIGH_LEVEL, UART0_DMA_irq_handler); AIC_EnableIT(AT91C_ID_US0); // AT91F_AIC_EnableIt (AT91C_BASE_AIC, AT91C_ID_US0); //w��czenie USART0 USART_SetReceiverEnabled(AT91C_BASE_US0, 1); USART_SetTransmitterEnabled(AT91C_BASE_US0, 1); // AT91C_BASE_US0->US_CR = AT91C_US_RXEN | /* Receiver Enable */ // AT91C_US_TXEN; /* Transmitter Enable */ //wlaczenie DMA (nadawanie) PDC_Enable(AT91C_BASE_PDC_US0); //konfiguracja wyprowadzen AT91F_PIO_CfgPeriph(AT91C_BASE_PIOA, (AT91C_PA5_RXD0 | AT91C_PA6_TXD0), 0); //wlaczenie przerwania od odbiornika AT91C_BASE_US0->US_IER = (0x1 << 0); //RXRDY }
//------------------------------------------------------------------------------ /// Application entry point. Configures the DBGU, PIT, TC0, LEDs and buttons /// and makes LED\#1 blink in its infinite loop, using the Wait function. /// \return Unused (ANSI-C compatibility). //------------------------------------------------------------------------------ int main(void) { // DBGU configuration TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK); TRACE_INFO_WP("\n\r"); TRACE_INFO("Getting new Started Project --\n\r"); TRACE_INFO("%s\n\r", BOARD_NAME); TRACE_INFO("Compiled: %s %s --\n\r", __DATE__, __TIME__); //Configure Reset Controller AT91C_BASE_RSTC->RSTC_RMR= 0xa5<<24; // Configure EMAC PINS PIO_Configure(emacRstPins, PIO_LISTSIZE(emacRstPins)); // Execute reset RSTC_SetExtResetLength(0xd); RSTC_ExtReset(); // Wait for end hardware reset while (!RSTC_GetNrstLevel()); TRACE_INFO("init Flash\n\r"); flash_init(); TRACE_INFO("init Timer\n\r"); // Configure timer 0 ticks=0; extern void ISR_Timer0(); AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0); AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF; AT91C_BASE_TC0->TC_SR; AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCTRG; AT91C_BASE_TC0->TC_RC = 375; AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS; AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_Timer0); AIC_EnableIT(AT91C_ID_TC0); AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; // Configure timer 1 extern void ISR_Timer1(); AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1); AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; //Stop clock AT91C_BASE_TC1->TC_IDR = 0xFFFFFFFF; //Disable Interrupts AT91C_BASE_TC1->TC_SR; //Read Status register AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV4_CLOCK | AT91C_TC_CPCTRG; // Timer1: 2,666us = 48MHz/128 AT91C_BASE_TC1->TC_RC = 0xffff; AT91C_BASE_TC1->TC_IER = AT91C_TC_CPCS; AIC_ConfigureIT(AT91C_ID_TC1, 1, ISR_Timer1); AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG; led_init(); TRACE_INFO("init EEprom\n\r"); eeprom_init(); rb_reset(&TTY_Rx_Buffer); rb_reset(&TTY_Tx_Buffer); input_handle_func = analyze_ttydata; LED_OFF(); LED2_OFF(); LED3_OFF(); spi_init(); fht_init(); tx_init(); #ifdef HAS_ETHERNET ethernet_init(); #endif TRACE_INFO("init USB\n\r"); CDCDSerialDriver_Initialize(); USBD_Connect(); wdt_enable(WDTO_2S); fastrf_on=0; display_channel = DISPLAY_USB; TRACE_INFO("init Complete\n\r"); checkFrequency(); // Main loop while (1) { CDC_Task(); Minute_Task(); RfAnalyze_Task(); #ifdef HAS_FASTRF FastRF_Task(); #endif #ifdef HAS_RF_ROUTER rf_router_task(); #endif #ifdef HAS_ASKSIN rf_asksin_task(); #endif #ifdef HAS_MORITZ rf_moritz_task(); #endif #ifdef HAS_RWE rf_rwe_task(); #endif #ifdef HAS_MBUS rf_mbus_task(); #endif #ifdef HAS_MAICO rf_maico_task(); #endif #ifdef HAS_ETHERNET Ethernet_Task(); #endif #ifdef DBGU_UNIT_IN if(DBGU_IsRxReady()){ unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM; unsigned char x; x=DBGU_GetChar(); switch(x) { case 'd': puts("USB disconnect\n\r"); USBD_Disconnect(); break; case 'c': USBD_Connect(); puts("USB Connect\n\r"); break; case 'r': //Configure Reset Controller AT91C_BASE_RSTC->RSTC_RMR=AT91C_RSTC_URSTEN | 0xa5<<24; break; case 'S': USBD_Disconnect(); my_delay_ms(250); my_delay_ms(250); //Reset *ram = 0xaa; AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24; while (1); break; default: rb_put(&TTY_Tx_Buffer, x); } } #endif if (USBD_GetState() == USBD_STATE_CONFIGURED) { if( USBState == STATE_IDLE ) { CDCDSerialDriver_Read(usbBuffer, DATABUFFERSIZE, (TransferCallback) UsbDataReceived, 0); LED3_ON(); USBState=STATE_RX; } } if( USBState == STATE_SUSPEND ) { TRACE_INFO("suspend !\n\r"); USBState = STATE_IDLE; } if( USBState == STATE_RESUME ) { TRACE_INFO("resume !\n\r"); USBState = STATE_IDLE; } } }