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; }