void ui_wakeup_enable(void)
{
// Configure PA15 as PIO input
pio_configure_pin(WAKEUP_PIN, WAKEUP_PIO_ATTR);
// Enable interrupt for PA15
pio_enable_pin_interrupt(WAKEUP_PIN);
// Enable fast wakeup for button pin (WKUP14 for PA15)
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);
}
static void irq_init(void) {
pio_configure_pin(DW_IRQ_IDX, DW_IRQ_FLAGS);
pio_pull_down(DW_IRQ_PIO, DW_IRQ_MASK, true);
pio_handler_set(DW_IRQ_PIO, DW_IRQ_PIO_ID, DW_IRQ_MASK, DW_IRQ_ATTR, irq_handler);
pio_enable_interrupt(DW_IRQ_PIO, DW_IRQ_MASK);
pio_handler_set_priority(DW_IRQ_PIO, DW_IRQ_IRQ, 0);
pmc_enable_periph_clk(DW_IRQ_PIO_ID);
}
/**
* \brief Disable receiver and Enable transmitter.
*/
static void func_transmitter(void)
{
/* Configure the TXD pin as peripheral. */
pio_configure_pin(PIN_USART_TXD_IDX, PIN_USART_TXD_FLAGS);
/* Disable Receiver. */
usart_disable_rx(BOARD_USART);
/* Enable transmitter. */
usart_enable_tx(BOARD_USART);
}
/*
* @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);
}
/**
* \name Main user interface functions
* @{
*/
void ui_init(void)
{
/* Enable PIO clock for button inputs */
pmc_enable_periph_clk(RESUME_PIO_ID);
pmc_enable_periph_clk(ID_PIOA);
/* 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);
pio_configure_pin(RESUME_PIN, RESUME_PIO_ATTR);
/* Initialize LEDs */
LED_Off(LED0);
}
/*
* @fn init_chip_pins
* @brief Initialize reset, chip enable and wake pin
*/
static void init_chip_pins(void)
{
#ifdef __SAM4SD32C__
pio_configure_pin(CONF_WINC_PIN_RESET, PIO_TYPE_PIO_OUTPUT_0|PIO_PULLUP);
pio_configure_pin(CONF_WINC_PIN_CHIP_ENABLE, PIO_TYPE_PIO_OUTPUT_0|PIO_PULLUP);
pio_configure_pin(CONF_WINC_PIN_WAKE, PIO_TYPE_PIO_OUTPUT_0|PIO_PULLUP);
pio_configure_pin(CONF_WINC_SPI_CS_GPIO, PIO_DEFAULT|PIO_PULLUP);
pio_set_pin_high(CONF_WINC_SPI_CS_GPIO);
#else
pio_configure_pin(CONF_WINC_PIN_RESET, PIO_TYPE_PIO_OUTPUT_0);
pio_configure_pin(CONF_WINC_PIN_CHIP_ENABLE, PIO_TYPE_PIO_OUTPUT_0);
pio_configure_pin(CONF_WINC_PIN_WAKE, PIO_TYPE_PIO_OUTPUT_0);
#endif
}
/**
* \brief Application entry point for smc_sram example.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
/* Initialize the SAM system */
sysclk_init();
board_init();
configure_console();
/* Output example information */
printf("\n\r\n\r\n\r");
printf("-- SMC SRAM Example --\n\r");
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/* Configure EBI I/O for SRAM connection */
printf("Configure EBI I/O for SRAM connection.\n\r");
/* Enable PMC clock for SMC */
pmc_enable_periph_clk(ID_SMC);
/* SMC configuration between SRAM and SMC waveforms. */
configure_sram(SRAM_CHIP_SELECT);
#ifdef SRAM_CHIP_SELECT_2ND
configure_sram(SRAM_CHIP_SELECT_2ND);
#endif
#ifdef PIN_EBI_NLB
/* Configure LB, enable SRAM access */
pio_configure_pin(PIN_EBI_NLB, PIN_EBI_NLB_FLAGS);
#endif
/* Test external SRAM access */
printf("Test external SRAM access. \n\r");
if (access_sram_test(SRAM_BASE_ADDRESS)) {
printf("SRAM access successful.\n\r");
} else {
printf("SRAM access failed.\n\r");
}
#ifdef SRAM_CHIP_SELECT_2ND
if (access_sram_test(SRAM_BASE_ADDRESS_2ND)) {
printf("2nd SRAM access successful.\n\r");
} else {
printf("2nd SRAM access failed.\n\r");
}
#endif
}
static void ext_sram_init(void)
{
pmc_enable_periph_clk(ID_SMC);
smc_set_setup_timing(SMC, 0, SMC_SETUP_NWE_SETUP(1)
| SMC_SETUP_NCS_WR_SETUP(1)
| SMC_SETUP_NRD_SETUP(1)
| SMC_SETUP_NCS_RD_SETUP(1));
smc_set_pulse_timing(SMC, 0, SMC_PULSE_NWE_PULSE(6)
| SMC_PULSE_NCS_WR_PULSE(6)
| SMC_PULSE_NRD_PULSE(6)
| SMC_PULSE_NCS_RD_PULSE(6));
smc_set_cycle_timing(SMC, 0, SMC_CYCLE_NWE_CYCLE(7)
| SMC_CYCLE_NRD_CYCLE(7));
smc_set_mode(SMC, 0,
SMC_MODE_READ_MODE | SMC_MODE_WRITE_MODE |
SMC_MODE_DBW_8_BIT);
/* Configure LB, enable SRAM access */
pio_configure_pin(PIN_EBI_NLB, PIN_EBI_NLB_FLAGS);
/* Pull down LB, enable sram access */
pio_set_pin_low(PIN_EBI_NLB);
}
/**
* \brief Disable transmitter and Enable receiver.
*/
static void func_receiver(void)
{
uint32_t ul_temp;
/* Disable Transmitter. */
usart_disable_tx(BOARD_USART);
/* Configure the TXD pin as PIO. */
pio_configure_pin(PIN_USART_TXD_IDX, PIN_USART_TXD_IO_FLAGS);
pio_set_pin_low(PIN_USART_TXD_IDX);
/* Enable receiver. */
usart_enable_rx(BOARD_USART);
/* Read dummy to make sure that there are no characters in US_THR! */
if (usart_is_rx_ready(BOARD_USART)) {
usart_read(BOARD_USART, &ul_temp);
/* avoid Cppcheck Warning */
UNUSED(ul_temp);
}
}
/**
* \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);
}
static int8_t dht_read_data(struct dht *self, int8_t *temperature, int8_t *humidity) {
uint8_t bits[5];
memset(bits, 0, sizeof(bits));
//reset port
pio_configure_pin(self->gpio, self->signal_pin, GP_OUTPUT);
pio_write_pin(self->gpio, self->signal_pin, 1);
delay_us(100000L);
// send request
pio_write_pin(self->gpio, self->signal_pin, 0);
if(self->sensor_type == DHT_DHT11)
delay_us(18000L);
else
delay_us(500);
pio_configure_pin(self->gpio, self->signal_pin, GP_INPUT | GP_PULLUP);
delay_us(40);
#define read_pin() pio_read_pin(self->gpio, self->signal_pin)
// start condition 1
if(read_pin())
return -1;
delay_us(80);
// start condition 2
if(!read_pin())
return -1;
delay_us(80);
//read the data
uint16_t timeoutcounter = 0;
for (int j=0; j<5; j++) { //read 5 byte
uint8_t result=0;
for(int i=0; i<8; i++) {//read every bit
timeoutcounter = 0;
while(!read_pin()) { //wait for an high input (non blocking)
timeoutcounter++;
if(timeoutcounter > DHT_TIMEOUT) {
return -1; //timeout
}
}
delay_us(30);
if(read_pin()) //if input is high after 30 us, get result
result |= (1<<(7-i));
timeoutcounter = 0;
while(read_pin()) { //wait until input get low (blocking)
timeoutcounter++;
if(timeoutcounter > DHT_TIMEOUT) {
return -1; //timeout
}
}
}
bits[j] = result;
}
//reset port
pio_configure_pin(self->gpio, self->signal_pin, GP_OUTPUT);
pio_write_pin(self->gpio, self->signal_pin, 0);
//check checksum
if ((uint8_t)(bits[0] + bits[1] + bits[2] + bits[3]) == bits[4]) {
//return temperature and humidity
if(self->sensor_type == DHT_DHT11){
*temperature = bits[2];
*humidity = bits[0];
} else if(self->sensor_type == DHT_DHT22){
uint16_t rawhumidity = bits[0]<<8 | bits[1];
uint16_t rawtemperature = bits[2]<<8 | bits[3];
if(rawtemperature & 0x8000) {
*temperature = (float)((rawtemperature & 0x7FFF) / 10.0) * -1.0;
} else {
*temperature = (float)(rawtemperature)/10.0;
}
*humidity = (float)(rawhumidity)/10.0;
}
return 0;
}
return -1;
}
/*
* @fn init_chip_pins
* @brief Initialize reset, chip enable and wake pin
*/
static void init_chip_pins(void)
{
pio_configure_pin(CONF_WILC_PIN_RESET, PIO_TYPE_PIO_OUTPUT_0);
pio_configure_pin(CONF_WILC_PIN_CHIP_ENABLE, PIO_TYPE_PIO_OUTPUT_0);
pio_configure_pin(CONF_WILC_PIN_WAKE, PIO_TYPE_PIO_OUTPUT_0);
}
void board_init(void)
{
#ifndef CONF_BOARD_KEEP_WATCHDOG_AT_INIT
/* Disable the watchdog */
WDT->WDT_MR = WDT_MR_WDDIS;
#endif
/* GPIO has been deprecated, the old code just keeps it for compatibility.
* In new designs IOPORT is used instead.
* Here IOPORT must be initialized for others to use before setting up IO.
*/
ioport_init();
/* Configure LED pins */
gpio_configure_pin(LED0_GPIO, LED0_FLAGS);
gpio_configure_pin(LED1_GPIO, LED1_FLAGS);
/* Configure Push Button pins */
gpio_configure_pin(GPIO_PUSH_BUTTON_1, GPIO_PUSH_BUTTON_1_FLAGS);
#ifdef CONF_BOARD_UART_CONSOLE
/* Configure UART pins */
gpio_configure_group(PINS_UART0_PIO, PINS_UART0, PINS_UART0_FLAGS);
#endif
#ifdef CONF_BOARD_TWI0
gpio_configure_pin(TWI0_DATA_GPIO, TWI0_DATA_FLAGS);
gpio_configure_pin(TWI0_CLK_GPIO, TWI0_CLK_FLAGS);
#endif
#ifdef CONF_BOARD_TWI1
gpio_configure_pin(TWI1_DATA_GPIO, TWI1_DATA_FLAGS);
gpio_configure_pin(TWI1_CLK_GPIO, TWI1_CLK_FLAGS);
#endif
/* Configure SPI pins */
#ifdef CONF_BOARD_SPI
gpio_configure_pin(SPI_MISO_GPIO, SPI_MISO_FLAGS);
gpio_configure_pin(SPI_MOSI_GPIO, SPI_MOSI_FLAGS);
gpio_configure_pin(SPI_SPCK_GPIO, SPI_SPCK_FLAGS);
/**
* For NPCS 1, 2, and 3, different PINs can be used to access the same NPCS line.
* Depending on the application requirements, the default PIN may not be available.
* Hence a different PIN should be selected using the CONF_BOARD_SPI_NPCS_GPIO and
* CONF_BOARD_SPI_NPCS_FLAGS macros.
*/
#ifdef CONF_BOARD_SPI_NPCS0
gpio_configure_pin(SPI_NPCS0_GPIO, SPI_NPCS0_FLAGS);
#endif
#ifdef CONF_BOARD_SPI_NPCS1
#if defined(CONF_BOARD_SPI_NPCS1_GPIO) && defined(CONF_BOARD_SPI_NPCS1_FLAGS)
gpio_configure_pin(CONF_BOARD_SPI_NPCS1_GPIO, CONF_BOARD_SPI_NPCS1_FLAGS);
#else
gpio_configure_pin(SPI_NPCS1_PA31_GPIO, SPI_NPCS1_PA31_FLAGS);
#endif
#endif
#ifdef CONF_BOARD_SPI_NPCS2
#if defined(CONF_BOARD_SPI_NPCS2_GPIO) && defined(CONF_BOARD_SPI_NPCS2_FLAGS)
gpio_configure_pin(CONF_BOARD_SPI_NPCS2_GPIO, CONF_BOARD_SPI_NPCS2_FLAGS);
#else
gpio_configure_pin(SPI_NPCS2_PA30_GPIO, SPI_NPCS2_PA30_FLAGS);
#endif
#endif
#ifdef CONF_BOARD_SPI_NPCS3
#if defined(CONF_BOARD_SPI_NPCS3_GPIO) && defined(CONF_BOARD_SPI_NPCS3_FLAGS)
gpio_configure_pin(CONF_BOARD_SPI_NPCS3_GPIO, CONF_BOARD_SPI_NPCS3_FLAGS);
#else
gpio_configure_pin(SPI_NPCS3_PA22_GPIO, SPI_NPCS3_PA22_FLAGS);
#endif
#endif
#endif
#ifdef CONF_BOARD_USART_RXD
/* Configure USART RXD pin */
gpio_configure_pin(PIN_USART1_RXD_IDX, PIN_USART1_RXD_FLAGS);
#endif
#ifdef CONF_BOARD_USART_TXD
/* Configure USART TXD pin */
gpio_configure_pin(PIN_USART1_TXD_IDX, PIN_USART1_TXD_FLAGS);
#endif
#ifdef CONF_BOARD_USART_CTS
/* Configure USART CTS pin */
gpio_configure_pin(PIN_USART1_CTS_IDX, PIN_USART1_CTS_FLAGS);
#endif
#ifdef CONF_BOARD_USART_RTS
/* Configure USART RTS pin */
gpio_configure_pin(PIN_USART1_RTS_IDX, PIN_USART1_RTS_FLAGS);
#endif
#ifdef CONF_BOARD_USART_SCK
/* Configure USART synchronous communication SCK pin */
gpio_configure_pin(PIN_USART1_SCK_IDX, PIN_USART1_SCK_FLAGS);
#endif
#ifdef CONF_BOARD_SRAM
pio_configure_pin(PIN_EBI_NCS0, PIN_EBI_NCS0_FLAGS);
pio_configure_pin(PIN_EBI_NRD, PIN_EBI_NRD_FLAGS);
pio_configure_pin(PIN_EBI_NWE, PIN_EBI_NWE_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D0, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D1, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D2, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D3, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D4, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D5, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D6, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_DATA_BUS_D7, PIN_EBI_DATA_BUS_FLAGS);
pio_configure_pin(PIN_EBI_ADDR_BUS_A0, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A1, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A2, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A3, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A4, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A5, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A6, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A7, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A8, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A9, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A10, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A11, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A12, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A13, PIN_EBI_ADDR_BUS_FLAG1);
pio_configure_pin(PIN_EBI_ADDR_BUS_A14, PIN_EBI_ADDR_BUS_FLAG2);
pio_configure_pin(PIN_EBI_ADDR_BUS_A15, PIN_EBI_ADDR_BUS_FLAG2);
pio_configure_pin(PIN_EBI_ADDR_BUS_A16, PIN_EBI_ADDR_BUS_FLAG2);
pio_configure_pin(PIN_EBI_ADDR_BUS_A17, PIN_EBI_ADDR_BUS_FLAG2);
pio_configure_pin(PIN_EBI_ADDR_BUS_A18, PIN_EBI_ADDR_BUS_FLAG2);
#endif
#ifdef CONF_BOARD_MMA7341L
/* Configure MMA7341L mode set control pin */
gpio_configure_pin(PIN_MMA7341L_MODE, PIN_MMA7341L_MODE_FLAG);
/* Configure MMA7341L x,y,z axis output voltage pin */
gpio_configure_pin(PIN_MMA7341L_X_AXIS, PIN_MMA7341L_X_AXIS_FLAG);
gpio_configure_pin(PIN_MMA7341L_Y_AXIS, PIN_MMA7341L_Y_AXIS_FLAG);
gpio_configure_pin(PIN_MMA7341L_Z_AXIS, PIN_MMA7341L_Z_AXIS_FLAG);
#endif
#if defined(CONF_BOARD_ENABLE_MXT143E_XPLAINED)
pio_configure_pin(MXT143E_XPLAINED_MISO, SPI_MISO_FLAGS);
pio_configure_pin(MXT143E_XPLAINED_MOSI, SPI_MOSI_FLAGS);
pio_configure_pin(MXT143E_XPLAINED_SCK, SPI_SPCK_FLAGS);
pio_configure_pin(MXT143E_XPLAINED_CS, (PIO_OUTPUT_0 | PIO_DEFAULT));
pio_configure_pin(MXT143E_XPLAINED_CHG, (PIO_INPUT | PIO_PULLUP));
pio_configure_pin(MXT143E_XPLAINED_DC, (PIO_OUTPUT_0 | PIO_DEFAULT));
#ifndef MXT143E_XPLAINED_BACKLIGHT_DISABLE
pio_configure_pin(MXT143E_XPLAINED_BACKLIGHT, (PIO_OUTPUT_0 | PIO_DEFAULT));
#endif
pio_configure_pin(MXT143E_XPLAINED_LCD_RESET, (PIO_OUTPUT_0 | PIO_DEFAULT));
pio_configure_pin(MXT143E_XPLAINED_SDA, TWI0_DATA_FLAGS);
pio_configure_pin(MXT143E_XPLAINED_SCL, TWI0_CLK_FLAGS);
pmc_enable_periph_clk(ID_PIOB);
#endif
}
void board_init(void)
{
#ifndef CONF_BOARD_KEEP_WATCHDOG_AT_INIT
/* Disable the watchdog */
WDT->WDT_MR = WDT_MR_WDDIS;
#endif
/* Initialize IOPORTs */
ioport_init();
/* Configure the pins connected to LED as output and set their
* default initial state to high (LED off).
*/
ioport_set_pin_dir(LED0_GPIO, IOPORT_DIR_OUTPUT);
ioport_set_pin_level(LED0_GPIO, LED0_INACTIVE_LEVEL);
ioport_set_pin_dir(LED1_GPIO, IOPORT_DIR_OUTPUT);
ioport_set_pin_level(LED1_GPIO, LED0_INACTIVE_LEVEL);
/* Configure Push Button pins */
ioport_set_pin_input_mode(GPIO_PUSH_BUTTON_1, GPIO_PUSH_BUTTON_1_FLAGS,
GPIO_PUSH_BUTTON_1_SENSE);
#ifdef CONF_BOARD_UART_CONSOLE
/* Configure UART pins */
ioport_set_pin_peripheral_mode(USART1_RXD_GPIO, USART1_RXD_FLAGS);
MATRIX->CCFG_SYSIO |= CCFG_SYSIO_SYSIO4;
ioport_set_pin_peripheral_mode(USART1_TXD_GPIO, USART1_TXD_FLAGS);
#endif
#ifdef CONF_BOARD_TWIHS0
ioport_set_pin_peripheral_mode(TWIHS0_DATA_GPIO, TWIHS0_DATA_FLAGS);
ioport_set_pin_peripheral_mode(TWIHS0_CLK_GPIO, TWIHS0_CLK_FLAGS);
#endif
#ifdef CONF_BOARD_CAN0
/* Configure the CAN0 TX and RX pins. */
ioport_set_pin_peripheral_mode(PIN_CAN0_RX_IDX, PIN_CAN0_RX_FLAGS);
ioport_set_pin_peripheral_mode(PIN_CAN0_TX_IDX, PIN_CAN0_TX_FLAGS);
/* Configure the transiver0 RS & EN pins. */
ioport_set_pin_dir(PIN_CAN0_TR_RS_IDX, IOPORT_DIR_OUTPUT);
ioport_set_pin_dir(PIN_CAN0_TR_EN_IDX, IOPORT_DIR_OUTPUT);
#endif
#ifdef CONF_BOARD_CAN1
/* Configure the CAN1 TX and RX pin. */
ioport_set_pin_peripheral_mode(PIN_CAN1_RX_IDX, PIN_CAN1_RX_FLAGS);
ioport_set_pin_peripheral_mode(PIN_CAN1_TX_IDX, PIN_CAN1_TX_FLAGS);
#endif
#ifdef CONF_BOARD_SPI
ioport_set_pin_peripheral_mode(SPI0_MISO_GPIO, SPI0_MISO_FLAGS);
ioport_set_pin_peripheral_mode(SPI0_MOSI_GPIO, SPI0_MOSI_FLAGS);
ioport_set_pin_peripheral_mode(SPI0_NPCS0_GPIO, SPI0_NPCS0_FLAGS);
ioport_set_pin_peripheral_mode(SPI0_SPCK_GPIO, SPI0_SPCK_FLAGS);
#endif
#ifdef CONF_BOARD_QSPI
ioport_set_pin_peripheral_mode(QSPI_QSCK_GPIO, QSPI_QSCK_FLAGS);
ioport_set_pin_peripheral_mode(QSPI_QCS_GPIO, QSPI_QCS_FLAGS);
ioport_set_pin_peripheral_mode(QSPI_QIO0_GPIO, QSPI_QIO0_FLAGS);
ioport_set_pin_peripheral_mode(QSPI_QIO1_GPIO, QSPI_QIO1_FLAGS);
ioport_set_pin_peripheral_mode(QSPI_QIO2_GPIO, QSPI_QIO2_FLAGS);
ioport_set_pin_peripheral_mode(QSPI_QIO3_GPIO, QSPI_QIO3_FLAGS);
#endif
#ifdef CONF_BOARD_PWM_LED0
/* Configure PWM LED0 pin */
ioport_set_pin_peripheral_mode(PIN_PWM_LED0_GPIO, PIN_PWM_LED0_FLAGS);
#endif
#ifdef CONF_BOARD_PWM_LED1
/* Configure PWM LED1 pin */
ioport_set_pin_peripheral_mode(PIN_PWM_LED1_GPIO, PIN_PWM_LED1_FLAGS);
#endif
#ifdef CONF_BOARD_USART_RXD
/* Configure USART RXD pin */
ioport_set_pin_peripheral_mode(USART0_RXD_GPIO, USART0_RXD_FLAGS);
#endif
#ifdef CONF_BOARD_USART_TXD
/* Configure USART TXD pin */
ioport_set_pin_peripheral_mode(USART0_TXD_GPIO, USART0_TXD_FLAGS);
#endif
#ifdef CONF_BOARD_USART_SCK
/* Configure USART synchronous communication SCK pin */
ioport_set_pin_peripheral_mode(PIN_USART0_SCK_IDX,PIN_USART0_SCK_FLAGS);
#endif
#ifdef CONF_BOARD_USART_CTS
/* Configure USART synchronous communication CTS pin */
ioport_set_pin_peripheral_mode(PIN_USART0_CTS_IDX,PIN_USART0_CTS_FLAGS);
#endif
#ifdef CONF_BOARD_USART_RTS
/* Configure USART RTS pin */
ioport_set_pin_peripheral_mode(PIN_USART0_RTS_IDX, PIN_USART0_RTS_FLAGS);
#endif
#ifdef CONF_BOARD_SD_MMC_HSMCI
/* Configure HSMCI pins */
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCCDA_GPIO, PIN_HSMCI_MCCDA_FLAGS);
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCCK_GPIO, PIN_HSMCI_MCCK_FLAGS);
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCDA0_GPIO, PIN_HSMCI_MCDA0_FLAGS);
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCDA1_GPIO, PIN_HSMCI_MCDA1_FLAGS);
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCDA2_GPIO, PIN_HSMCI_MCDA2_FLAGS);
ioport_set_pin_peripheral_mode(PIN_HSMCI_MCDA3_GPIO, PIN_HSMCI_MCDA3_FLAGS);
ioport_set_pin_peripheral_mode(SD_MMC_0_CD_GPIO, SD_MMC_0_CD_FLAGS);
#endif
#ifdef CONF_BOARD_ILI9488
/**LCD pin configure on EBI*/
pio_configure(PIN_EBI_RESET_PIO, PIN_EBI_RESET_TYPE, PIN_EBI_RESET_MASK, PIN_EBI_RESET_ATTRI);
pio_configure(PIN_EBI_CDS_PIO, PIN_EBI_CDS_TYPE, PIN_EBI_CDS_MASK, PIN_EBI_CDS_ATTRI);
pio_configure(PIN_EBI_DATAL_PIO, PIN_EBI_DATAL_TYPE, PIN_EBI_DATAL_MASK, PIN_EBI_DATAL_ATTRI);
pio_configure(PIN_EBI_DATAH_0_PIO, PIN_EBI_DATAH_0_TYPE, PIN_EBI_DATAH_0_MASK, PIN_EBI_DATAH_0_ATTRI);
pio_configure(PIN_EBI_DATAH_1_PIO, PIN_EBI_DATAH_1_TYPE, PIN_EBI_DATAH_1_MASK, PIN_EBI_DATAH_1_ATTRI);
pio_configure(PIN_EBI_NWE_PIO, PIN_EBI_NWE_TYPE, PIN_EBI_NWE_MASK, PIN_EBI_NWE_ATTRI);
pio_configure(PIN_EBI_NRD_PIO, PIN_EBI_NRD_TYPE, PIN_EBI_NRD_MASK, PIN_EBI_NRD_ATTRI);
pio_configure(PIN_EBI_CS_PIO, PIN_EBI_CS_TYPE, PIN_EBI_CS_MASK, PIN_EBI_CS_ATTRI);
pio_configure(PIN_EBI_BACKLIGHT_PIO, PIN_EBI_BACKLIGHT_TYPE, PIN_EBI_BACKLIGHT_MASK, PIN_EBI_BACKLIGHT_ATTRI);
pio_set(PIN_EBI_BACKLIGHT_PIO, PIN_EBI_BACKLIGHT_MASK);
#endif
#if (defined CONF_BOARD_USB_PORT)
# if defined(CONF_BOARD_USB_VBUS_DETECT)
ioport_set_pin_dir(USB_VBUS_PIN, IOPORT_DIR_INPUT);
# endif
# if defined(CONF_BOARD_USB_ID_DETECT)
ioport_set_pin_dir(USB_ID_PIN, IOPORT_DIR_INPUT);
# endif
#endif
#ifdef CONF_BOARD_SDRAMC
pio_configure_pin(SDRAM_BA0_PIO, SDRAM_BA0_FLAGS);
pio_configure_pin(SDRAM_SDCK_PIO, SDRAM_SDCK_FLAGS);
pio_configure_pin(SDRAM_SDCKE_PIO, SDRAM_SDCKE_FLAGS);
pio_configure_pin(SDRAM_SDCS_PIO, SDRAM_SDCS_FLAGS);
pio_configure_pin(SDRAM_RAS_PIO, SDRAM_RAS_FLAGS);
pio_configure_pin(SDRAM_CAS_PIO, SDRAM_CAS_FLAGS);
pio_configure_pin(SDRAM_SDWE_PIO, SDRAM_SDWE_FLAGS);
pio_configure_pin(SDRAM_NBS0_PIO, SDRAM_NBS0_FLAGS);
pio_configure_pin(SDRAM_NBS1_PIO, SDRAM_NBS1_FLAGS);
pio_configure_pin(SDRAM_A2_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A3_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A4_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A5_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A6_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A7_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A8_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A9_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A10_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_A11_PIO, SDRAM_A_FLAGS);
pio_configure_pin(SDRAM_SDA10_PIO, SDRAM_SDA10_FLAGS);
pio_configure_pin(SDRAM_D0_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D1_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D2_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D3_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D4_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D5_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D6_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D7_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D8_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D9_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D10_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D11_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D12_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D13_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D14_PIO, SDRAM_D_FLAGS);
pio_configure_pin(SDRAM_D15_PIO, SDRAM_D_FLAGS);
MATRIX->CCFG_SMCNFCS = CCFG_SMCNFCS_SDRAMEN;
#endif
#ifdef CONF_BOARD_CONFIG_MPU_AT_INIT
_setup_memory_region();
#endif
}
/**
* Configure all device pins
*/
static void pins_init(void)
{
bool configure_pin (const struct pin_info *pin) {
pio_configure_pin(pin->index, pin->flags);
return true;
}
