示例#1
0
/**
 * \brief Test alarm interrupt and wakeup functions in calendar/counter mode.
 *
 * \param test Current test case.
 */
static void run_alarm_test(const struct test_case *test)
{
	uint32_t ast_alarm, ast_counter;
	struct ast_calendar calendar;
	struct ast_config ast_conf;

	/* Enable the AST. */
	ast_enable(AST);

	/* Set alarm 0 to interrupt after 1 second in calendar mode. */
	calendar.FIELD.sec = 0;
	calendar.FIELD.min = 15;
	calendar.FIELD.hour = 12;
	calendar.FIELD.day = 20;
	calendar.FIELD.month = 9;
	calendar.FIELD.year = 12;
	ast_conf.mode = AST_CALENDAR_MODE;
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ;
	ast_conf.calendar = calendar;
	ast_set_config(AST, &ast_conf);

	/* Set callback for alarm0. */
	ast_clear_interrupt_flag(AST, AST_INTERRUPT_ALARM);
	ast_write_alarm0_value(AST, calendar.field + 1);
	ast_set_callback(AST, AST_INTERRUPT_ALARM, ast_alarm_callback,
		AST_ALARM_IRQn, 1);

	flag = 0;
	delay_ms(1500);
	test_assert_true(test, flag == 2, "Alarm interrupt not work!");

	/* Set alarm 0 to wakeup after 1 second in counter mode. */
	ast_conf.mode = AST_COUNTER_MODE;
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ - 2;
	ast_conf.counter = 0;
	ast_set_config(AST, &ast_conf);

	/* ast_init_counter Set Alarm to current time+4 quarter second. */
	ast_counter = ast_read_counter_value(AST);
	ast_alarm = ast_counter + 4;
	ast_write_alarm0_value(AST, ast_alarm);
	ast_enable_interrupt(AST, AST_INTERRUPT_ALARM);
	ast_enable_wakeup(AST, AST_WAKEUP_ALARM);

	/* AST can wakeup the device. */
	bpm_enable_wakeup_source(BPM, (1 << BPM_BKUPWEN_AST));

	flag = 0;
	/* Go into WAIT mode. */
	bpm_sleep(BPM, BPM_SM_WAIT);
	delay_ms(1000);
	test_assert_true(test, flag == 2, "Alarm wakeup not work!");

	/* Disable the AST. */
	ast_disable(AST);
}
/* Override the default definition of vPortSetupTimerInterrupt() that is weakly
defined in the FreeRTOS Cortex-M3 port layer with a version that configures the
asynchronous timer (AST) to generate the tick interrupt. */
void vPortSetupTimerInterrupt( void )
{
struct ast_config ast_conf;

	/* Ensure the AST can bring the CPU out of sleep mode. */
	sleepmgr_lock_mode( SLEEPMGR_RET );

	/* Ensure the 32KHz oscillator is enabled. */
	if( osc_is_ready( OSC_ID_OSC32 ) == pdFALSE )
	{
		osc_enable( OSC_ID_OSC32 );
		osc_wait_ready( OSC_ID_OSC32 );
	}

	/* Enable the AST itself. */
	ast_enable( AST );

	ast_conf.mode = AST_COUNTER_MODE;  /* Simple up counter. */
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = 0; /* No prescale so the actual frequency is 32KHz/2. */
	ast_conf.counter = 0;
	ast_set_config( AST, &ast_conf );

	/* The AST alarm interrupt is used as the tick interrupt.  Ensure the alarm
	status starts clear. */
	ast_clear_interrupt_flag( AST, AST_INTERRUPT_ALARM );

	/* Enable wakeup from alarm 0 in the AST and power manager.  */
	ast_enable_wakeup( AST, AST_WAKEUP_ALARM );
	bpm_enable_wakeup_source( BPM, ( 1 << BPM_BKUPWEN_AST ) );

	/* Tick interrupt MUST execute at the lowest interrupt priority. */
	NVIC_SetPriority( AST_ALARM_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY);
	ast_enable_interrupt( AST, AST_INTERRUPT_ALARM );
	NVIC_ClearPendingIRQ( AST_ALARM_IRQn );
	NVIC_EnableIRQ( AST_ALARM_IRQn );

	/* Automatically clear the counter on interrupt. */
	ast_enable_counter_clear_on_alarm( AST, portAST_ALARM_CHANNEL );

	/* Start with the tick active and generating a tick with regular period. */
	ast_write_alarm0_value( AST, ulAlarmValueForOneTick );
	ast_write_counter_value( AST, 0 );

	/* See the comments where xMaximumPossibleSuppressedTicks is declared. */
	xMaximumPossibleSuppressedTicks = ULONG_MAX / ulAlarmValueForOneTick;
}
示例#3
0
/**
 * \brief Test periodic interrupt and wakeup functions in counter mode.
 *
 * \param test Current test case.
 */
static void run_periodic_test(const struct test_case *test)
{
	struct ast_config ast_conf;

	/* Enable the AST. */
	ast_enable(AST);

	ast_conf.mode = AST_COUNTER_MODE;
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ;
	ast_conf.counter = 0;
	ast_set_config(AST, &ast_conf);

	/* Set periodic 0 to interrupt after 1/16 second in counter mode. */
	ast_clear_interrupt_flag(AST, AST_INTERRUPT_PER);
	ast_write_periodic0_value(AST, AST_PSEL_32KHZ_1HZ - 4);
	/* Set callback for periodic0. */
	flag = 0;
	ast_set_callback(AST, AST_INTERRUPT_PER, ast_per_callback,
		AST_PER_IRQn, 1);
	delay_ms(200);
	test_assert_true(test, flag == 1, "Periodic interrupt not work!");

	/* Set periodic 0 to wakeup after 1/16 second in counter mode. */
	while (!(ast_read_interrupt_mask(AST) & AST_IMR_PER0_1)) {
		ast_enable_interrupt(AST, AST_INTERRUPT_PER);
	}
	ast_enable_wakeup(AST, AST_WAKEUP_PER);

	/* AST can wakeup the device. */
	bpm_enable_wakeup_source(BPM, (1 << BPM_BKUPWEN_AST));

	flag = 0;
	/* Go into WAIT mode. */
	bpm_sleep(BPM, BPM_SM_WAIT);
	delay_ms(200);
	test_assert_true(test, flag == 1, "Periodic wakeup not work!");
	ast_disable_interrupt(AST, AST_INTERRUPT_PER);

	/* Disable the AST. */
	ast_disable(AST);
}
示例#4
0
static void config_ast(void)
{
	struct ast_config ast_conf;

	/* Enable osc32 oscillator*/
	if (!osc_is_ready(OSC_ID_OSC32)) {
		osc_enable(OSC_ID_OSC32);
		osc_wait_ready(OSC_ID_OSC32);
	}

	/* Enable the AST */
	ast_enable(AST);

	ast_conf.mode = AST_COUNTER_MODE;
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ;
	ast_conf.counter = 0;

	/*
	 * Using counter mode and set it to 0.
	 * Initialize the AST.
	 */
	if (!ast_set_config(AST, &ast_conf)) {
		printf("Error initializing the AST\r\n");
		while (1) {
		}
	}

	/* First clear alarm status. */
	ast_clear_interrupt_flag(AST, AST_INTERRUPT_ALARM);

	/* Enable wakeup from alarm0. */
	ast_enable_wakeup(AST, AST_WAKEUP_ALARM);

	/* Set callback for alarm0. */
	ast_set_callback(AST, AST_INTERRUPT_ALARM, ast_alarm_callback,
		AST_ALARM_IRQn, 1);

	/* Disable first interrupt for alarm0. */
	ast_disable_interrupt(AST, AST_INTERRUPT_ALARM);

}
示例#5
0
/**
 * \brief Run BPM driver unit tests.
 */
int main(void)
{
	struct ast_config ast_conf;

	const usart_serial_options_t usart_serial_options = {
		.baudrate = CONF_TEST_BAUDRATE,
		.charlength = CONF_TEST_CHARLENGTH,
		.paritytype = CONF_TEST_PARITY,
		.stopbits = CONF_TEST_STOPBITS
	};

	sysclk_init();
	board_init();
	stdio_serial_init(CONF_TEST_USART, &usart_serial_options);

	/* Initialize AST for all tests */
	/* Enable osc32 oscillator*/
	if (!osc_is_ready(OSC_ID_OSC32)) {
		osc_enable(OSC_ID_OSC32);
		osc_wait_ready(OSC_ID_OSC32);
	}

	/* Enable the AST. */
	ast_enable(AST);

	ast_conf.mode = AST_COUNTER_MODE;
	ast_conf.osc_type = AST_OSC_32KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ;
	ast_conf.counter = 0;
	ast_set_config(AST, &ast_conf);

	/* Set periodic 0 to interrupt after 1/16 second in counter mode. */
	ast_clear_interrupt_flag(AST, AST_INTERRUPT_PER);
	ast_write_periodic0_value(AST, AST_PSEL_32KHZ_1HZ - 2);

	ast_set_callback(AST, AST_INTERRUPT_PER, ast_per_callback,
		AST_PER_IRQn, 1);

	ast_enable_wakeup(AST, AST_WAKEUP_PER);

	/* AST can wakeup the device */
	bpm_enable_wakeup_source(BPM, (1 << BPM_BKUPWEN_AST));
	/**
	 * Retain I/O lines after wakeup from backup.
	 * Disable to undo the previous retention state then enable.
	 */
	bpm_disable_io_retention(BPM);
	bpm_enable_io_retention(BPM);
	/* Enable fast wakeup */
	bpm_enable_fast_wakeup(BPM);

	/* Define all the test cases. */
	DEFINE_TEST_CASE(backup_test, NULL, run_backup_test, NULL,
			"Backup Power Manager, Backup mode & wakeup.");
	DEFINE_TEST_CASE(ps_test, NULL, run_ps_test, NULL,
			"Backup Power Manager, Power Scaling.");
	DEFINE_TEST_CASE(ret_test, NULL, run_ret_test, NULL,
			"Backup Power Manager, Retention mode & wakeup.");
	DEFINE_TEST_CASE(wait_test, NULL, run_wait_test, NULL,
			"Backup Power Manager, Wait mode & wakeup.");
	DEFINE_TEST_CASE(sleep_3_test, NULL, run_sleep_3_test, NULL,
			"Backup Power Manager, Sleep mode 3 & wakeup.");
	DEFINE_TEST_CASE(sleep_2_test, NULL, run_sleep_2_test, NULL,
			"Backup Power Manager, Sleep mode 2 & wakeup.");
	DEFINE_TEST_CASE(sleep_1_test, NULL, run_sleep_1_test, NULL,
			"Backup Power Manager, Sleep mode 1 & wakeup.");
	DEFINE_TEST_CASE(sleep_0_test, NULL, run_sleep_0_test, NULL,
			"Backup Power Manager, Sleep mode 0 & wakeup.");

	/* Put test case addresses in an array. */
	DEFINE_TEST_ARRAY(bpm_tests) = {
			&backup_test,
			&ps_test,
			&ret_test,
			&wait_test,
			&sleep_3_test,
			&sleep_2_test,
			&sleep_1_test,
			&sleep_0_test,
			};

	/* Define the test suite. */
	DEFINE_TEST_SUITE(bpm_suite, bpm_tests, "SAM BPM driver test suite");

	/* Run all tests in the test suite. */
	test_suite_run(&bpm_suite);

	/* Disable the AST */
	ast_disable(AST);

	while (1) {
		/* Busy-wait forever. */
	}
}
示例#6
0
int main(void)
{
	enum sleepmgr_mode current_sleep_mode = SLEEPMGR_ACTIVE;
	uint32_t ast_counter = 0;

	/*
	 * Initialize the synchronous clock system to the default configuration
	 * set in conf_clock.h.
	 * \note All non-essential peripheral clocks are initially disabled.
	 */
	sysclk_init();

	/*
	 * Initialize the resources used by this example to the default
	 * configuration set in conf_board.h
	 */
	board_init();

	/*
	 * Turn the activity status LED on to inform the user that the device
	 * is active.
	 */
	ioport_set_pin_level(LED_ACTIVITY_STATUS_PIN, LED_STATUS_ON);

	osc_priv_enable_osc32();

	/* Enable the AST clock. */
	ast_enable(AST);

	/* Initialize the AST in Counter mode. */
	struct ast_config ast_conf;
	ast_conf.mode = AST_COUNTER_MODE;
	ast_conf.osc_type = AST_OSC_1KHZ;
	ast_conf.psel = AST_PSEL_32KHZ_1HZ - 6;
	ast_conf.counter = ast_counter;
	ast_set_config(AST, &ast_conf);

	/*
	 * Configure the AST to wake up the CPU when the counter reaches the
	 * selected periodic0 value.
	 */
	ast_write_periodic0_value(AST, AST_PSEL_32KHZ_1HZ - 3);
	ast_enable_wakeup(AST, AST_WAKEUP_PER);
	ast_enable_event(AST, AST_EVENT_PER);
	ast_clear_interrupt_flag(AST, AST_INTERRUPT_PER);
	ast_set_callback(AST, AST_INTERRUPT_PER, ast_per_interrupt_callback,
			AST_PER_IRQn, 0);

	/* AST can wakeup the device */
	bpm_enable_wakeup_source(BPM, (1 << BPM_BKUPWEN_AST));

	/* Initialize the sleep manager, lock initial mode.*/
	sleepmgr_init();
	sleepmgr_lock_mode(current_sleep_mode);

	while (1) {
		/*
		 * Turn the activity status LED off to inform the user that the
		 * device is in a sleep mode.
		 */
		ioport_set_pin_level(LED_ACTIVITY_STATUS_PIN, LED_STATUS_OFF);

		/*
		 * Go to sleep in the deepest allowed sleep mode (i.e. no
		 * deeper than the currently locked sleep mode).
		 */
		sleepmgr_enter_sleep();

		/*
		 * Turn the activity status LED on to inform the user that the
		 * device is active.
		 */
		ioport_set_pin_level(LED_ACTIVITY_STATUS_PIN, LED_STATUS_ON);

		/* Unlock the current sleep mode. */
		sleepmgr_unlock_mode(current_sleep_mode);

		/* Add a 3s delay. */
		delay_s(3);

		/* Lock the next sleep mode. */
		++current_sleep_mode;
		if ((current_sleep_mode >= SLEEPMGR_NR_OF_MODES)) {
			current_sleep_mode = SLEEPMGR_ACTIVE;
		}

		sleepmgr_lock_mode(current_sleep_mode);
	}
}