/**
* \brief Interrupt handler for the RTC. Refresh the display.
*/
void RTC_Handler(void)
{
uint32_t ul_status = rtc_get_status(RTC);
/* Second increment interrupt */
if ((ul_status & RTC_SR_SEC) == RTC_SR_SEC) {
/* Disable RTC interrupt */
rtc_disable_interrupt(RTC, RTC_IDR_SECDIS);
refresh_display();
rtc_clear_status(RTC, RTC_SCCR_SECCLR);
rtc_enable_interrupt(RTC, RTC_IER_SECEN);
} else {
/* Time or date alarm */
if ((ul_status & RTC_SR_ALARM) == RTC_SR_ALARM) {
/* Disable RTC interrupt */
rtc_disable_interrupt(RTC, RTC_IDR_ALRDIS);
gs_ul_alarm_triggered = 1;
refresh_display();
/* Show additional menu item for clear notification */
gs_ul_menu_shown = 0;
rtc_clear_status(RTC, RTC_SCCR_ALRCLR);
rtc_enable_interrupt(RTC, RTC_IER_ALREN);
}
}
}
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();
}
/**
* \brief Application entry point for RTC example.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint8_t uc_key;
/* Initialize the SAM system */
sysclk_init();
board_init();
/* Initialize the console uart */
configure_console();
/* Output example information */
puts(STRING_HEADER);
/* Default RTC configuration, 24-hour mode */
rtc_set_hour_mode(RTC, 0);
/* Configure RTC interrupts */
NVIC_DisableIRQ(RTC_IRQn);
NVIC_ClearPendingIRQ(RTC_IRQn);
NVIC_SetPriority(RTC_IRQn, 0);
NVIC_EnableIRQ(RTC_IRQn);
rtc_enable_interrupt(RTC, RTC_IER_SECEN | RTC_IER_ALREN);
/* Refresh display once */
refresh_display();
/* Handle keypresses */
while (1) {
while (uart_read(CONSOLE_UART, &uc_key));
/* Set time */
if (uc_key == 't') {
gs_ul_state = STATE_SET_TIME;
do {
puts("\n\r\n\r Set time(hh:mm:ss): ");
} while (get_new_time());
/* If valid input, none of the variables for time is 0xff. */
if (gs_ul_new_hour != 0xFFFFFFFF && (gs_uc_rtc_time[2] == ':')
&& (gs_uc_rtc_time[5] == ':')) {
if (rtc_set_time(RTC, gs_ul_new_hour, gs_ul_new_minute,
gs_ul_new_second)) {
puts("\n\r Time not set, invalid input!\r");
}
} else {
gs_uc_rtc_time[2] = ':';
gs_uc_rtc_time[5] = ':';
puts("\n\r Time not set, invalid input!\r");
}
gs_ul_state = STATE_MENU;
gs_ul_menu_shown = 0;
refresh_display();
}
/* Set date */
if (uc_key == 'd') {
gs_ul_state = STATE_SET_DATE;
do {
puts("\n\r\n\r Set date(mm/dd/yyyy): ");
} while (get_new_date());
/* If valid input, none of the variables for date is 0xff(ff). */
if (gs_ul_new_year != 0xFFFFFFFF && (gs_uc_date[2] == '/')
&& (gs_uc_date[5] == '/')) {
if (rtc_set_date(RTC, gs_ul_new_year, gs_ul_new_month,
gs_ul_new_day, gs_ul_new_week)) {
puts("\n\r Date not set, invalid input!\r");
}
} else {
gs_uc_date[2] = '/';
gs_uc_date[5] = '/';
puts("\n\r Time not set, invalid input!\r");
}
/* Only 'mm/dd' is input. */
if (gs_ul_new_month != 0xFFFFFFFF &&
gs_ul_new_year == 0xFFFFFFFF) {
puts("\n\r Not Set for no year field!\r");
}
gs_ul_state = STATE_MENU;
gs_ul_menu_shown = 0;
refresh_display();
}
/* Set time alarm */
if (uc_key == 'i') {
gs_ul_state = STATE_SET_TIME_ALARM;
rtc_clear_date_alarm(RTC);
do {
puts("\n\r\n\r Set time alarm(hh:mm:ss): ");
} while (get_new_time());
if (gs_ul_new_hour != 0xFFFFFFFF && (gs_uc_rtc_time[2] == ':')
&& (gs_uc_rtc_time[5] == ':')) {
if (rtc_set_time_alarm(RTC, 1, gs_ul_new_hour,
1, gs_ul_new_minute, 1, gs_ul_new_second)) {
puts("\n\r Time alarm not set, invalid input!\r");
} else {
printf("\n\r Time alarm is set at %02u:%02u:%02u!",
(unsigned int)gs_ul_new_hour, (unsigned int)gs_ul_new_minute,
(unsigned int)gs_ul_new_second);
}
} else {
gs_uc_rtc_time[2] = ':';
gs_uc_rtc_time[5] = ':';
puts("\n\r Time not set, invalid input!\r");
}
gs_ul_state = STATE_MENU;
gs_ul_menu_shown = 0;
gs_ul_alarm_triggered = 0;
refresh_display();
}
/* Set date alarm */
if (uc_key == 'm') {
gs_ul_state = STATE_SET_DATE_ALARM;
rtc_clear_time_alarm(RTC);
do {
puts("\n\r\n\r Set date alarm(mm/dd/yyyy): ");
} while (get_new_date());
if (gs_ul_new_year != 0xFFFFFFFF && (gs_uc_date[2] == '/')
&& (gs_uc_date[5] == '/')) {
if (rtc_set_date_alarm(RTC, 1, gs_ul_new_month, 1,
gs_ul_new_day)) {
puts("\n\r Date alarm not set, invalid input!\r");
} else {
printf("\n\r Date alarm is set on %02u/%02u/%4u!",
(unsigned int)gs_ul_new_month, (unsigned int)gs_ul_new_day,
(unsigned int)gs_ul_new_year);
}
} else {
gs_uc_date[2] = '/';
gs_uc_date[5] = '/';
puts("\n\r Date alarm not set, invalid input!\r");
}
gs_ul_state = STATE_MENU;
gs_ul_menu_shown = 0;
gs_ul_alarm_triggered = 0;
refresh_display();
}
#if ((SAM3S8) || (SAM3SD8) || (SAM4S) || (SAM4C) || (SAM4CP) || (SAM4CM))
/* Generate Waveform */
if (uc_key == 'w') {
gs_ul_state = STATE_WAVEFORM;
puts("\n\rMenu:\n\r"
" 0 - No Waveform\n\r"
" 1 - 1 Hz square wave\n\r"
" 2 - 32 Hz square wave\n\r"
" 3 - 64 Hz square wave\n\r"
" 4 - 512 Hz square wave\n\r"
" 5 - Toggles when alarm flag rise\n\r"
" 6 - Copy of the alarm flag\n\r"
" 7 - Duty cycle programmable pulse\n\r"
" 8 - Quit\r");
while (1) {
while (uart_read(CONSOLE_UART, &uc_key));
if ((uc_key >= '0') && (uc_key <= '7')) {
rtc_set_waveform(RTC, 0, char_to_digit(uc_key));
}
if (uc_key == '8') {
gs_ul_state = STATE_MENU;
gs_ul_menu_shown = 0;
refresh_display();
break;
}
}
}
#endif
/* Clear trigger flag */
if (uc_key == 'c') {
gs_ul_alarm_triggered = 0;
gs_ul_menu_shown = 0;
refresh_display();
}
}
}
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();
}
int main(void)
{
system_init();
rtc_init_counter_mode();
rtc_start();
//test_fec_encoding();
//test_fec_decoding();
button_enable_interrupts();
phy_init();
phy_set_rx_callback(rx_callback);
while(1) {
if (INTERRUPT_BUTTON1 & interrupt_flags) {
interrupt_flags &= ~INTERRUPT_BUTTON1;
// led_toggle(1);
start_tx();
button_clear_interrupt_flag();
button_enable_interrupts();
}
if (INTERRUPT_BUTTON3 & interrupt_flags) {
interrupt_flags &= ~INTERRUPT_BUTTON3;
if (rtcEnabled) {
rtcEnabled = 0;
rtc_disable_interrupt();
} else {
rtcEnabled = 1;
rtc_enable_interrupt();
}
button_clear_interrupt_flag();
button_enable_interrupts();
}
if (INTERRUPT_RTC & interrupt_flags) {
interrupt_flags &= ~INTERRUPT_RTC;
led_toggle(0);
start_tx();
}
if (!phy_is_rx_in_progress() && !phy_is_tx_in_progress()) {
start_rx();
}
if (phy_is_rx_in_progress())
{
led_on(2);
} else {
led_off(2);
}
if (phy_is_tx_in_progress())
{
led_on(3);
} else {
led_off(3);
}
// system_lowpower_mode(4,1);
}
return 0;
}
/*!
* \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;
}
}
}