OSStatus platform_powersave_enable_wakeup_pin( const platform_gpio_t* gpio )
{
#ifndef MICO_DISABLE_MCU_POWERSAVE
if ( gpio->is_wakeup_pin == true )
{
/* Enable wake-up pin */
pmc_set_fast_startup_input( 1 << gpio->wakeup_pin_number );
if ( gpio->trigger == IOPORT_SENSE_RISING )
{
/* Set polarity of corresponding wake-up pin bit to active-high */
PMC->PMC_FSPR |= (uint32_t)( 1 << gpio->wakeup_pin_number );
}
else
{
/* Set polarity of corresponding wake-up pin bit to active-low */
PMC->PMC_FSPR &= ~(uint32_t)( 1 << gpio->wakeup_pin_number );
}
return kNoErr;
}
else
{
return kGeneralErr;
}
#else /* MICO_DISABLE_MCU_POWERSAVE */
return kNoErr;
#endif
}
OSStatus platform_mcu_powersave_init(void)
{
#ifndef MICO_DISABLE_MCU_POWERSAVE
#error Not working currently, uncomment MICO_DISABLE_MCU_POWERSAVE in platform_config.h
/* Initialise all pins to be input pull-up to save power */
ioport_enable_port( IOPORT_PIOA, 0xffffffffU );
ioport_set_port_mode( IOPORT_PIOA, 0xffffffffU, IOPORT_MODE_PULLUP );
ioport_set_port_dir( IOPORT_PIOA, 0xffffffffU, IOPORT_DIR_INPUT );
ioport_enable_port( IOPORT_PIOB, 0xffffffffU );
ioport_set_port_mode( IOPORT_PIOB, 0xffffffffU, IOPORT_MODE_PULLUP );
ioport_set_port_dir( IOPORT_PIOB, 0xffffffffU, IOPORT_DIR_INPUT );
NVIC_DisableIRQ( RTT_IRQn );
NVIC_ClearPendingIRQ( RTT_IRQn );
NVIC_EnableIRQ( RTT_IRQn );
pmc_set_fast_startup_input( PMC_FSMR_RTTAL );
rtt_init( RTT, RTT_CLOCK_PRESCALER );
rtt_write_alarm_time( RTT, 64000 );
#endif /* MICO_DISABLE_MCU_POWERSAVE */
return kNoErr;
}
/**
* \brief Initializes and enables interrupt pin change
*/
static void ui_enable_asynchronous_interrupt(void)
{
/* Enable interrupt for button pin */
pio_get_interrupt_status(PIOB);
pio_enable_pin_interrupt(GPIO_PUSH_BUTTON_2);
/* Enable fastwakeup for button pin */
pmc_set_fast_startup_input(PMC_FSMR_FSTT14);
}
/**
* \brief Initializes and enables interrupt pin change
*/
static void ui_enable_asynchronous_interrupt(void)
{
/* Enable interrupt for button pin */
pio_get_interrupt_status(RESUME_PIO);
pio_enable_pin_interrupt(RESUME_PIN);
/* Enable fast wakeup for button pin */
pmc_set_fast_startup_input(RESUME_PMC_FSTT);
}
void ui_wakeup_enable(void)
{
// Enable interrupt for button pin
pio_configure_pin(WAKEUP_PIN, WAKEUP_PIO_ATTR);
pio_enable_pin_interrupt(WAKEUP_PIN);
// Enable fast wakeup for button pin
pmc_set_fast_startup_input(WAKEUP_PMC_FSTT);
}
void ui_wakeup_enable(void)
{
/* Configure BP3 as PIO input */
pio_configure_pin(WAKEUP_PIN, WAKEUP_PIO_ATTR);
/* Enable interrupt for BP3 */
pio_enable_pin_interrupt(WAKEUP_PIN);
/* Enable fast wakeup for button pin (WKUP10 for PA20) */
pmc_set_fast_startup_input(WAKEUP_PMC_FSTT);
}
void udd_enable(void)
{
irqflags_t flags;
flags = cpu_irq_save();
#if SAMG55
matrix_set_usb_device();
#endif
// Enable USB hardware
udd_enable_periph_ck();
sysclk_enable_usb();
// Cortex, uses NVIC, no need to register IRQ handler
NVIC_SetPriority((IRQn_Type) ID_UDP, UDD_USB_INT_LEVEL);
NVIC_EnableIRQ((IRQn_Type) ID_UDP);
// Reset internal variables
#if (0!=USB_DEVICE_MAX_EP)
udd_ep_job_table_reset();
#endif
// Always authorize asynchronous USB interrupts to exit of sleep mode
pmc_set_fast_startup_input(PMC_FSMR_USBAL);
#ifndef UDD_NO_SLEEP_MGR
// Initialize the sleep mode authorized for the USB suspend mode
udd_b_idle = false;
sleepmgr_lock_mode(UDP_SLEEP_MODE_USB_SUSPEND);
#endif
#if UDD_VBUS_IO
/* Initialize VBus monitor */
udd_vbus_init(udd_vbus_handler);
udd_vbus_monitor_sleep_mode(true);
/* Force Vbus interrupt when Vbus is always high
* This is possible due to a short timing between a Host mode stop/start.
*/
if (Is_udd_vbus_high()) {
udd_vbus_handler(USB_VBUS_PIO_ID, USB_VBUS_PIO_MASK);
}
#else
# ifndef USB_DEVICE_ATTACH_AUTO_DISABLE
udd_attach();
# endif
#endif
cpu_irq_restore(flags);
}
/**
* \name Main user interface functions
* @{
*/
void ui_init(void)
{
/* Enable PIO clock for button inputs */
pmc_enable_periph_clk(ID_PIOB);
pmc_enable_periph_clk(ID_PIOE);
/* Set handler for wakeup */
pio_handler_set(RESUME_PIO, RESUME_PIO_ID, RESUME_PIO_MASK,
RESUME_PIO_ATTR, ui_wakeup_handler);
/* Enable IRQ for button (PIOB) */
NVIC_EnableIRQ((IRQn_Type)RESUME_PIO_ID);
/* Enable interrupt for button pin */
pio_get_interrupt_status(RESUME_PIO);
pio_configure_pin(RESUME_PIN, RESUME_PIO_ATTR);
pio_enable_pin_interrupt(RESUME_PIN);
/* Enable fastwakeup for button pin */
pmc_set_fast_startup_input(RESUME_PMC_FSTT);
/* Initialize LEDs */
LED_Off(LED0_GPIO);
LED_Off(LED1_GPIO);
LED_Off(LED2_GPIO);
LED_Off(LED3_GPIO);
}
int main(void)
{
enum sleepmgr_mode current_sleep_mode = SLEEPMGR_ACTIVE;
/*
* 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);
rtt_init(RTT, 32768);
/* Enable RTT interrupt */
NVIC_DisableIRQ(RTT_IRQn);
NVIC_ClearPendingIRQ(RTT_IRQn);
NVIC_SetPriority(RTT_IRQn, 0);
NVIC_EnableIRQ(RTT_IRQn);
rtt_enable_interrupt(RTT, RTT_MR_ALMIEN);
/* Set wakeup source to rtt_alarm */
pmc_set_fast_startup_input(PMC_FSMR_RTTAL);
#if (!SAMG)
supc_set_wakeup_mode(SUPC, SUPC_WUMR_RTTEN_ENABLE);
#endif
/* Initialize the sleep manager, lock initial mode. */
sleepmgr_init();
sleepmgr_lock_mode(current_sleep_mode);
while (1) {
rtt_write_alarm_time(RTT, rtt_read_timer_value(RTT) + SLEEP_TIME);
/*
* 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(ACTIVE_TIME);
/* 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);
}
}
void udd_enable(void)
{
irqflags_t flags;
flags = cpu_irq_save();
#ifdef UHD_ENABLE
// DUAL ROLE INITIALIZATION
if (otg_dual_enable()) {
// The current mode has been started by otg_dual_enable()
cpu_irq_restore(flags);
return;
}
#else
// SINGLE DEVICE MODE INITIALIZATION
sysclk_enable_usb();
pmc_enable_periph_clk(ID_UOTGHS);
// Here, only the device mode is possible, then link UHDP interrupt to UDD interrupt
NVIC_SetPriority((IRQn_Type) ID_UOTGHS, USB_INT_LEVEL);
NVIC_EnableIRQ((IRQn_Type) ID_UOTGHS);
// Always authorize asynchrony USB interrupts to exit of sleep mode
// For SAM USB wake up device except BACKUP mode
pmc_set_fast_startup_input(PMC_FSMR_USBAL);
#endif
#if (OTG_ID_IO) && (defined UHD_ENABLE)
// Check that the device mode is selected by ID pin
if (!Is_otg_id_device()) {
cpu_irq_restore(flags);
return; // Device is not the current mode
}
#else
// ID pin not used and force device mode
otg_force_device_mode();
#endif
// Enable USB hardware
otg_enable();
// Reset internal variables
#if (0!=USB_DEVICE_MAX_EP)
udd_ep_job_table_reset();
#endif
#ifndef UDD_NO_SLEEP_MGR
if (!udd_b_sleep_initialized) {
udd_b_sleep_initialized = true;
// Initialize the sleep mode authorized for the USB suspend mode
udd_b_idle = false;
sleepmgr_lock_mode(UHDP_SLEEP_MODE_USB_SUSPEND);
} else {
udd_sleep_mode(false); // Enter idle mode
}
#endif
#if OTG_VBUS_IO
/* Initialize VBus monitor */
otg_vbus_init(udd_vbus_handler);
udd_vbus_monitor_sleep_mode(true);
/* Force VBus interrupt when VBus is always high
* This is possible due to a short timing between a Host mode stop/start.
*/
if (Is_otg_vbus_high()) {
udd_vbus_handler(USB_VBUS_PIO_ID, USB_VBUS_PIO_MASK);
}
#else
# ifndef USB_DEVICE_ATTACH_AUTO_DISABLE
udd_attach();
# endif
#endif
cpu_irq_restore(flags);
}