/**
* \brief Initialize SAM4E_XPRO board for low power test.
*/
void init_specific_board(void)
{
/* Disable all Extra functions in matrix except for SWD CLK/IO */
matrix_set_system_io(0x00001C30);
/* Configure all PIOs as inputs to save power */
pio_set_input(PIOA, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOB, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOC, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOD, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOE, 0xFFFFFFFF, PIO_PULLUP);
/* Disable USB Clock */
pmc_disable_udpck();
/* Disable pull-up on PHY */
pio_pull_up(PIOD, PIO_PD0 | PIO_PD4 | PIO_PD5 | PIO_PD6 | PIO_PD7, 0);
/* Hold PHY in reset to avoid the clock output switching */
pio_set_output(PIOD, PIO_PD31, 0, 0, 0);
/* Disable pull-up on VBUS */
pio_pull_up(PIOE, PIO_PE2, 0);
/* Disable PIO pull-up for PB10(USB_DDM), PB11(USB_DDP) */
pio_pull_up(PIOB, PIO_PB10 | PIO_PB11, 0);
/* Enable the PMC clocks of push button for wakeup */
pmc_enable_periph_clk(ID_PIOE);
pio_handler_set_priority(PIOE, PIOE_IRQn, IRQ_PRIOR_PIO);
}
/**
* \brief Configure one or more pin(s) of a PIO controller as outputs, with
* the given default value. Optionally, the multi-drive feature can be enabled
* on the pin(s).
*
* \param p_pio Pointer to a PIO instance.
* \param ul_mask Bitmask indicating which pin(s) to configure.
* \param ul_default_level Default level on the pin(s).
* \param ul_multidrive_enable Indicates if the pin(s) shall be configured as
* open-drain.
* \param ul_pull_up_enable Indicates if the pin shall have its pull-up
* activated.
*/
void pio_set_output(Pio *p_pio, const uint32_t ul_mask,
const uint32_t ul_default_level,
const uint32_t ul_multidrive_enable,
const uint32_t ul_pull_up_enable)
{
pio_disable_interrupt(p_pio, ul_mask);
pio_pull_up(p_pio, ul_mask, ul_pull_up_enable);
/* Enable multi-drive if necessary */
if (ul_multidrive_enable) {
p_pio->PIO_MDER = ul_mask;
} else {
p_pio->PIO_MDDR = ul_mask;
}
/* Set default value */
if (ul_default_level) {
p_pio->PIO_SODR = ul_mask;
} else {
p_pio->PIO_CODR = ul_mask;
}
/* Configure pin(s) as output(s) */
p_pio->PIO_OER = ul_mask;
p_pio->PIO_PER = ul_mask;
}
/**
* \brief Perform complete pin(s) configuration; general attributes and PIO init
* if necessary.
*
* \param p_pio Pointer to a PIO instance.
* \param ul_type PIO type.
* \param ul_mask Bitmask of one or more pin(s) to configure.
* \param ul_attribute Pins attributes.
*
* \return Whether the pin(s) have been configured properly.
*/
uint32_t pio_configure(Pio *p_pio, const pio_type_t ul_type,
const uint32_t ul_mask, const uint32_t ul_attribute)
{
/* Configure pins */
switch (ul_type) {
case PIO_PERIPH_A:
case PIO_PERIPH_B:
# if (SAM3S || SAM3N || SAM4S)
case PIO_PERIPH_C:
case PIO_PERIPH_D:
# endif
pio_set_peripheral(p_pio, ul_type, ul_mask);
pio_pull_up(p_pio, ul_mask, (ul_attribute & PIO_PULLUP));
break;
case PIO_INPUT:
pio_set_input(p_pio, ul_mask, ul_attribute);
break;
case PIO_OUTPUT_0:
case PIO_OUTPUT_1:
pio_set_output(p_pio, ul_mask, (ul_type == PIO_OUTPUT_1),
(ul_attribute & PIO_OPENDRAIN) ? 1 : 0,
(ul_attribute & PIO_PULLUP) ? 1 : 0);
break;
default:
return 0;
}
return 1;
}
/**
* \brief Initialize SAM4E_EK board for low power test.
*/
void init_specific_board(void)
{
/* Configure all PIOs as inputs to save power */
pio_set_input(PIOA, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOB, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOC, 0xFFFFFFFF, PIO_PULLUP);
/* Disable USB Clock */
pmc_disable_udpck();
/* Disable PIO pull-up for PB10(USB_DDM), PB11(USB_DDP) */
pio_pull_up(PIOB, (0x3 << 10), 0);
/* Disable PIO pull-up for PC21(USB_CNX) */
pio_pull_up(PIOC, (0x1 << 21), 0);
/* Enable the PMC clocks of push button for wakeup */
pmc_enable_periph_clk(ID_PIOA);
pio_handler_set_priority(PIOA, PIOA_IRQn, IRQ_PRIOR_PIO);
}
extern "C" void setPullup(Pin pin, bool en)
{
if (pin <= MaxPinNumber)
{
const PinDescription& pinDesc = g_APinDescription[pin];
if (pinDesc.ulPinType != PIO_NOT_A_PIN)
{
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, (uint32_t)en) ;
}
}
}
/*
* @fn nm_bsp_register_isr
* @brief Register interrupt service routine
* @param[IN] pfIsr
* Pointer to ISR handler
*/
void nm_bsp_register_isr(tpfNmBspIsr pfIsr)
{
gpfIsr = pfIsr;
/* Configure PGIO pin for interrupt from SPI slave, used when slave has data to send. */
sysclk_enable_peripheral_clock(CONF_WINC_SPI_INT_PIO_ID);
pio_configure_pin(CONF_WINC_SPI_INT_PIN, PIO_TYPE_PIO_INPUT);
pio_pull_up(CONF_WINC_SPI_INT_PIO, CONF_WINC_SPI_INT_MASK, PIO_PULLUP);
// pio_set_debounce_filter(CONF_WINC_SPI_INT_PIO, CONF_WINC_SPI_INT_MASK, 10);
pio_handler_set_pin(CONF_WINC_SPI_INT_PIN, PIO_IT_LOW_LEVEL, chip_isr);
pio_enable_interrupt(CONF_WINC_SPI_INT_PIO, CONF_WINC_SPI_INT_MASK);
pio_handler_set_priority(CONF_WINC_SPI_INT_PIO, (IRQn_Type)CONF_WINC_SPI_INT_PIO_ID,
CONF_WINC_SPI_INT_PRIORITY);
}
/**
* \brief Initialize SAM3N_EK board for low power test.
*/
void init_specific_board(void)
{
/* Configure all PIOs as inputs to save power */
pio_set_input(PIOA, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOB, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOC, 0xFFFFFFFF, PIO_PULLUP);
/* Disable USB Clock */
pmc_disable_upll_clock();
/* Disable PIO pull-up for PA0 (VBUS_USB) */
pio_pull_up(PIOA, (0x1 << 0), 0);
/* Initialize ADC pin as ADC input mode to save power */
adc_enable_channel(ADC, ADC_CHANNEL_0);
adc12b_enable_channel(ADC12B, ADC_CHANNEL_3);
/* Enable the PMC clocks of push button for wakeup */
pmc_enable_periph_clk(ID_PIOA);
pio_handler_set_priority(PIOA, PIOA_IRQn, IRQ_PRIOR_PIO);
}
/**
* \brief Configure one or more pin(s) or a PIO controller as inputs.
* Optionally, the corresponding internal pull-up(s) and glitch filter(s) can
* be enabled.
*
* \param p_pio Pointer to a PIO instance.
* \param ul_mask Bitmask indicating which pin(s) to configure as input(s).
* \param ul_attribute PIO attribute(s).
*/
void pio_set_input(Pio *p_pio, const uint32_t ul_mask,
const uint32_t ul_attribute)
{
pio_disable_interrupt(p_pio, ul_mask);
pio_pull_up(p_pio, ul_mask, ul_attribute & PIO_PULLUP);
/* Enable Input Filter if necessary */
if (ul_attribute & (PIO_DEGLITCH | PIO_DEBOUNCE)) {
p_pio->PIO_IFER = ul_mask;
} else {
p_pio->PIO_IFDR = ul_mask;
}
#if (SAM3S || SAM3N || SAM4S)
/* Enable de-glitch or de-bounce if necessary */
if (ul_attribute & PIO_DEGLITCH) {
p_pio->PIO_IFSCDR = ul_mask;
} else {
if (ul_attribute & PIO_DEBOUNCE) {
p_pio->PIO_IFSCER = ul_mask;
}
}
#elif (SAM3XA|| SAM3U)
/* Enable de-glitch or de-bounce if necessary */
if (ul_attribute & PIO_DEGLITCH) {
p_pio->PIO_SCIFSR = ul_mask;
} else {
if (ul_attribute & PIO_DEBOUNCE) {
p_pio->PIO_SCIFSR = ul_mask;
}
}
#else
#error "Unsupported device"
#endif
/* Configure pin as input */
p_pio->PIO_ODR = ul_mask;
p_pio->PIO_PER = ul_mask;
}
static void Configure ( void )
{
// ------- Configure the UART connected to the AVR controller -------
if ( ENABLE_DEBUG_CONSOLE )
{
VERIFY( pio_configure( PIOA, PIO_PERIPH_A,
PIO_PA8A_URXD | PIO_PA9A_UTXD, PIO_DEFAULT ) );
// Enable the pull-up resistor for RX0.
pio_pull_up( PIOA, PIO_PA8A_URXD, ENABLE ) ;
InitSerialPort( false );
SerialSyncWriteStr( "--- EmptyDue " PACKAGE_VERSION " ---" EOL );
SerialSyncWriteStr( "Welcome to the Arduino Due's programming USB serial port." EOL );
}
SetUserPanicMsgFunction( &PrintPanicMsg );
// ------- Perform some assorted checks -------
assert( IsJtagTdoPullUpActive() );
// Check that the brown-out detector is active.
#ifndef NDEBUG
const uint32_t supcMr = SUPC->SUPC_MR;
assert( ( supcMr & SUPC_MR_BODDIS ) == SUPC_MR_BODDIS_ENABLE );
assert( ( supcMr & SUPC_MR_BODRSTEN ) == SUPC_MR_BODRSTEN_ENABLE );
#endif
// ------- Configure the watchdog -------
WDT->WDT_MR = WDT_MR_WDDIS;
}
/**
* \brief Initialize SAM3N_EK board for low power test.
*/
void init_specific_board(void)
{
/* Configure all PIOs as inputs to save power */
pio_set_input(PIOA, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOB, 0x0FFFFFFF, PIO_PULLUP); /* Exclude JTAG pins */
pio_set_input(PIOC, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOD, 0x7FFFFFFF, PIO_PULLUP);
pio_set_input(PIOE, 0xFFFFFFFF, PIO_PULLUP);
pio_set_input(PIOF, 0x3F, PIO_PULLUP);
/* Disable USB Clock */
pmc_disable_udpck();
pmc_disable_upll_clock();
/* Disable PIO pull-up for PB4, PB5, PB6, PB7 */
pio_pull_up(PIOB, (0xF << 4), 0);
/* Initialize ADC pin as ADC input mode to save power */
adc_enable_channel(ADC, ADC_CHANNEL_1);
/* Enable the PMC clocks of push button for wakeup */
pmc_enable_periph_clk(ID_PIOB);
pio_handler_set_priority(PIOB, PIOB_IRQn, IRQ_PRIOR_PIO);
}
extern "C" void pinModeDuet(Pin pin, enum PinMode ulMode, uint32_t debounceCutoff)
{
if (pin > MaxPinNumber)
{
return;
}
const PinDescription& pinDesc = g_APinDescription[pin];
if (pinDesc.ulPinType == PIO_NOT_A_PIN)
{
return;
}
switch (ulMode)
{
case INPUT:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
case INPUT_PULLUP:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? PIO_PULLUP : PIO_PULLUP | PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#if SAM4E
case INPUT_PULLDOWN:
/* Enable peripheral for clocking input */
pmc_enable_periph_clk(pinDesc.ulPeripheralId);
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0);
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 1);
pio_configure(
pinDesc.pPort,
PIO_INPUT,
pinDesc.ulPin,
(debounceCutoff == 0) ? 0 : PIO_DEBOUNCE);
if (debounceCutoff != 0)
{
pio_set_debounce_filter(pinDesc.pPort, pinDesc.ulPin, debounceCutoff); // enable debounce filer with specified cutoff frequency
}
break;
#endif
case OUTPUT_LOW:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_0,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_HIGH:
pio_configure(
pinDesc.pPort,
PIO_OUTPUT_1,
pinDesc.ulPin,
pinDesc.ulPinConfiguration);
/* if all pins are output, disable PIO Controller clocking, reduce power consumption */
if (pinDesc.pPort->PIO_OSR == 0xffffffff)
{
pmc_disable_periph_clk(pinDesc.ulPeripheralId);
}
break;
case OUTPUT_PWM_LOW:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 0.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case OUTPUT_PWM_HIGH:
if ((pinDesc.ulPinAttribute & (PIN_ATTR_PWM | PIN_ATTR_TIMER)) != 0)
{
AnalogOut(pin, 1.0, 0); // set it to zero frequency to force re-initialisation on next AnalogOut call
}
break;
case AIN:
pio_pull_up(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pullup
#if SAM4E
pio_pull_down(pinDesc.pPort, pinDesc.ulPin, 0); // turn off pulldown
#endif
// Ideally we should record which pins are being used as analog inputs, then we can disable the clock
// on any PIO that is being used solely for outputs and ADC inputs. But for now we don't do that.
break;
case SPECIAL:
ConfigurePin(pinDesc);
break;
default:
break;
}
}
