UART Rx TX Interrupt Beispiel für AT32UC3C-EK AVR32

static void usart_int_handler(void)

{

  int c;

  // The USART Rx interrupt flag is cleared by side effect when reading the

  // received character.

  // Waiting until the interrupt has actually been cleared is here useless as

  // the call to usart_write_char will take enough time for this before the

  // interrupt handler is leaved and the interrupt priority level is unmasked by

  // the CPU.

  usart_read_char(EXAMPLE_USART, &c);

  // Print the received character to USART.

  // It is a simple echo

  usart_write_char(EXAMPLE_USART, c);

}

int main(void)

{

  static const gpio_map_t USART_GPIO_MAP =

  {

    {EXAMPLE_USART_RX_PIN, EXAMPLE_USART_RX_FUNCTION},

    {EXAMPLE_USART_TX_PIN, EXAMPLE_USART_TX_FUNCTION}

  };

  // USART options.

  static const usart_options_t USART_OPTIONS =

  {

    .baudrate     = EXAMPLE_USART_BAUDRATE,

    .charlength   = 8,

    .paritytype   = USART_NO_PARITY,

    .stopbits     = USART_1_STOPBIT,

    .channelmode  = USART_NORMAL_CHMODE

  };

  // Configure Osc0 in crystal mode (i.e. use of an external crystal source, with

  // frequency FOSC0) with an appropriate startup time then switch the main clock

  // source to Osc0.

  pcl_switch_to_osc(PCL_OSC0, FOSC0, OSC0_STARTUP);

  // Assign GPIO to USART.

  gpio_enable_module(USART_GPIO_MAP,

                     sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));

  // Initialize USART in RS232 mode.

  usart_init_rs232(EXAMPLE_USART, &USART_OPTIONS, EXAMPLE_TARGET_PBACLK_FREQ_HZ);

  print(EXAMPLE_USART, ".: Using interrupts with the USART :.\r\n\r\n");

  // Disable all interrupts.

  Disable_global_interrupt();

  // Initialize interrupt vectors.

  INTC_init_interrupts();

  // Register the USART interrupt handler to the interrupt controller.

  // usart_int_handler is the interrupt handler to register.

  // EXAMPLE_USART_IRQ is the IRQ of the interrupt handler to register.

  // AVR32_INTC_INT0 is the interrupt priority level to assign to the group of

  // this IRQ.

  // void INTC_register_interrupt(__int_handler handler, unsigned int irq, unsigned int int_level);

  INTC_register_interrupt(&usart_int_handler, EXAMPLE_USART_IRQ, AVR32_INTC_INT0);

  // Enable USART Rx interrupt.

  EXAMPLE_USART->ier = AVR32_USART_IER_RXRDY_MASK;

  print(EXAMPLE_USART, "Type a character to use the interrupt handler.\r\n"

                       "It will show up on your screen.\r\n\r\n");

  // Enable all interrupts.

  Enable_global_interrupt();

  // When the USART interrupt occurs, this will wake the CPU up which will then

  // execute the interrupt handler code then come back to the while(1) loop below

  // to execute the sleep instruction again.

  while(1)

  {

    // If there is a chance that any PB write operations are incomplete, the CPU

    // should perform a read operation from any register on the PB bus before

    // executing the sleep instruction.

    AVR32_INTC.ipr[0];  // Dummy read

    // Go to FROZEN sleep mode.

    SLEEP(AVR32_PM_SMODE_FROZEN);

    // When the device wakes up due to an interrupt, once the interrupt is serviced,

    // go back into FROZEN sleep mode.

  }