/**
* @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;
}
}
}
