int rtc_init(volatile avr32_rtc_t *rtc, unsigned char osc_type, unsigned char psel)
{
// If exit, it means that the configuration has not been set correctly
if (osc_type > (1 << AVR32_RTC_CTRL_CLK32_SIZE) - 1 ||
psel > (1 << AVR32_RTC_CTRL_PSEL_SIZE) - 1)
return 0;
// If we use the 32-kHz oscillator, we have to enable it first
if (osc_type == RTC_OSC_32KHZ)
{
// Select the 32-kHz oscillator crystal
pm_enable_osc32_crystal(&AVR32_PM);
// Enable the 32-kHz clock and wait until the osc32 clock is ready.
pm_enable_clk32(&AVR32_PM, AVR32_PM_OSCCTRL32_STARTUP_0_RCOSC);
}
// Wait until the rtc accepts writes to the CTRL register
while (rtc_is_busy(rtc));
// Set the new RTC configuration
rtc->ctrl = osc_type << AVR32_RTC_CTRL_CLK32_OFFSET |
psel << AVR32_RTC_CTRL_PSEL_OFFSET |
AVR32_RTC_CTRL_CLKEN_MASK;
// Wait until write is done
while (rtc_is_busy(rtc));
// Set the counter value to 0
rtc_set_value(rtc, 0x00000000);
// Set the top value to 0xFFFFFFFF
rtc_set_top_value(rtc, 0xFFFFFFFF);
return 1;
}
static void ui_button_rtc_init(void)
{
irq_register_handler(button_rtc_irq, BUTTON_RTC_IRQ,
BUTTON_RTC_IRQ_PRIORITY);
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 7);
rtc_set_top_value(&AVR32_RTC, 0);
rtc_enable_interrupt(&AVR32_RTC);
rtc_enable(&AVR32_RTC);
}
static void ui_display_init_rtc(void)
{
irq_register_handler(display_rtc_irq, DISPLAY_RTC_IRQ,
DISPLAY_RTC_IRQ_PRIORITY);
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, RTC_PSEL_32KHZ_1HZ - 1);
rtc_enable_wake_up(&AVR32_RTC);
rtc_set_top_value(&AVR32_RTC, 0);
rtc_enable_interrupt(&AVR32_RTC);
rtc_enable(&AVR32_RTC);
}
void rtc_init_qt( void ) {
// Disable all interrupts. */
Disable_global_interrupt();
// Register the RTC interrupt handler to the interrupt controller.
INTC_register_interrupt(&rtc_irq, AVR32_RTC_IRQ, AVR32_INTC_INT0);
// Initialize the RTC
// Frtc = 1024Hz
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
// Set top value to 0 to generate an interrupt every seconds */
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
Enable_global_interrupt();
}
void rtc_init_qt( void ) {
// Init touch_states
controller_clear();
// Disable all interrupts
Disable_global_interrupt();
// Register the RTC interrupt handler to the interrupt controller.
BSP_INTC_IntReg( &rtc_irq, AVR32_RTC_IRQ, AVR32_INTC_INT1);
// Initialize the RTC
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
Enable_global_interrupt();
}
void controller_init(uint32_t fcpu_hz, uint32_t fhsb_hz, uint32_t fpbb_hz, uint32_t fpba_hz) {
static const gpio_map_t QT60168_SPI_GPIO_MAP = { { QT60168_SPI_SCK_PIN,
QT60168_SPI_SCK_FUNCTION }, // SPI Clock.
{ QT60168_SPI_MISO_PIN, QT60168_SPI_MISO_FUNCTION }, // MISO.
{ QT60168_SPI_MOSI_PIN, QT60168_SPI_MOSI_FUNCTION }, // MOSI.
{ QT60168_SPI_NPCS0_PIN, QT60168_SPI_NPCS0_FUNCTION } // Chip Select NPCS.
};
// SPI options.
spi_options_t spiOptions = {
.reg = QT60168_SPI_NCPS,
.baudrate = QT60168_SPI_MASTER_SPEED, // Defined in conf_qt60168.h.
.bits = QT60168_SPI_BITS, // Defined in conf_qt60168.h.
.spck_delay = 0, .trans_delay = 0, .stay_act = 0, .spi_mode = 3,
.modfdis = 1 };
// Assign I/Os to SPI.
gpio_enable_module(QT60168_SPI_GPIO_MAP, sizeof(QT60168_SPI_GPIO_MAP)
/ sizeof(QT60168_SPI_GPIO_MAP[0]));
// Set selection mode: variable_ps, pcs_decode, delay.
spi_selectionMode(QT60168_SPI, 0, 0, 0);
// Enable SPI.
spi_enable(QT60168_SPI);
// Initialize QT60168 with SPI clock Osc0.
spi_setupChipReg(QT60168_SPI, &spiOptions, fpba_hz);
// Initialize QT60168 component.
qt60168_init(fpba_hz);
// Init timer to get key value.
rtc_init_qt();
// Invalidate the timeout already
cpu_set_timeout(0, &cpu_time_clear_wheel);
}
void rtc_init_qt( void ) {
// Init touch_states
controller_clear();
// Disable all interrupts
cpu_irq_disable();
// Register the RTC interrupt handler to the interrupt controller.
irq_register_handler(rtc_irq, AVR32_RTC_IRQ, 0);
// Initialize the RTC
rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, 4);
rtc_set_top_value(&AVR32_RTC, 1);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
cpu_irq_enable();
}
/*!
* \brief main function : do init and loop (poll if configured so)
*/
int main( void )
{
char temp[20];
char *ptemp;
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 = 57600,
.charlength = 8,
.paritytype = USART_NO_PARITY,
.stopbits = USART_1_STOPBIT,
.channelmode = 0
};
pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP);
// Assign GPIO pins to USART0.
gpio_enable_module(USART_GPIO_MAP,
sizeof(USART_GPIO_MAP) / sizeof(USART_GPIO_MAP[0]));
// Initialize USART in RS232 mode at 12MHz.
usart_init_rs232(EXAMPLE_USART, &USART_OPTIONS, 12000000);
// Welcome sentence
usart_write_line(EXAMPLE_USART, "\x1B[2J\x1B[H\r\nATMEL\r\n");
usart_write_line(EXAMPLE_USART, "AVR32 UC3 - RTC example\r\n");
usart_write_line(EXAMPLE_USART, "RTC 32 KHz oscillator program test.\r\n");
// Disable all interrupts. */
Disable_global_interrupt();
// The INTC driver has to be used only for GNU GCC for AVR32.
#if __GNUC__
// Initialize interrupt vectors.
INTC_init_interrupts();
// Register the RTC interrupt handler to the interrupt controller.
INTC_register_interrupt(&rtc_irq, AVR32_RTC_IRQ, AVR32_INTC_INT0);
#endif
// Initialize the RTC
if (!rtc_init(&AVR32_RTC, RTC_OSC_32KHZ, RTC_PSEL_32KHZ_1HZ))
{
usart_write_line(&AVR32_USART0, "Error initializing the RTC\r\n");
while(1);
}
// Set top value to 0 to generate an interrupt every seconds */
rtc_set_top_value(&AVR32_RTC, 0);
// Enable the interrupts
rtc_enable_interrupt(&AVR32_RTC);
// Enable the RTC
rtc_enable(&AVR32_RTC);
// Enable global interrupts
Enable_global_interrupt();
while(1)
{
if (print_sec)
{
// Set cursor to the position (1; 5)
usart_write_line(EXAMPLE_USART, "\x1B[5;1H");
ptemp = print_i(temp, sec);
usart_write_line(EXAMPLE_USART, "Timer: ");
usart_write_line(EXAMPLE_USART, ptemp);
usart_write_line(EXAMPLE_USART, "s");
print_sec = 0;
}
}
}
