/* * Set up the GPIO pins and peripheral clocks for the SDIO * system. The code should probably take an option card detect * pin, at the moment it uses the one used by the Embest board. */ static void stm32_sdio_rcc_init(void) { /* Enable clocks for SDIO and DMA2 */ rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_SDIOEN); #ifdef WITH_DMA2 rcc_peripheral_enable_clock(&RCC_AHB1ENR, RCC_AHB1ENR_DMA2EN); #endif /* Setup GPIO Pins for SDIO: PC8 - PC11 - DAT0 thru DAT3 PC12 - CLK PD2 - CMD */ gpio_set_output_options(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_25MHZ, GPIO12 ); // All SDIO lines are push-pull, 25Mhz gpio_set_output_options(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_25MHZ, GPIO8 | GPIO9 | GPIO10 | GPIO11 ); // All SDIO lines are push-pull, 25Mhz gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO8 | GPIO9 | GPIO10 | GPIO11); // D0 - D3 enable pullups (bi-directional) gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO12); // CLK line no pullup gpio_set_af(GPIOC, GPIO_AF12, GPIO8 | GPIO9 | GPIO10 | GPIO11 | GPIO12); gpio_set_output_options(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_25MHZ, GPIO2); gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 | GPIO15); gpio_mode_setup(GPIOD, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO2); gpio_set_af(GPIOD, GPIO_AF12, GPIO2); #ifdef SDIO_HAS_CARD_DETECT /* SDIO Card Detect pin on the Embest Baseboard */ /* PB15 as a hacked Card Detect (active LOW for card present) */ gpio_mode_setup(GPIOB, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, GPIO15); #endif }
void mew_bluetooth_init(void) { gpio_mode_setup(MEW_BLUETOOTH_POWER_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, MEW_BLUETOOTH_POWER_PIN); gpio_set_output_options(MEW_BLUETOOTH_POWER_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_BLUETOOTH_POWER_PIN); gpio_clear(MEW_BLUETOOTH_POWER_PORT, MEW_BLUETOOTH_POWER_PIN); gpio_mode_setup(MEW_BLUETOOTH_RESET_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, MEW_BLUETOOTH_RESET_PIN); gpio_set_output_options(MEW_BLUETOOTH_RESET_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_BLUETOOTH_RESET_PIN); gpio_set(MEW_BLUETOOTH_RESET_PORT, MEW_BLUETOOTH_RESET_PIN); gpio_mode_setup(MEW_BLUETOOTH_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, MEW_BLUETOOTH_PIN); gpio_set_af(MEW_BLUETOOTH_PORT, MEW_BLUETOOTH_PORT_AF, MEW_BLUETOOTH_PIN); usart_disable(MEW_BLUETOOTH_USART); usart_set_baudrate(MEW_BLUETOOTH_USART, MEW_BLUETOOTH_SPEED); usart_set_databits(MEW_BLUETOOTH_USART, 8); usart_set_stopbits(MEW_BLUETOOTH_USART, USART_STOPBITS_1); usart_set_mode(MEW_BLUETOOTH_USART, USART_MODE_TX_RX); usart_set_parity(MEW_BLUETOOTH_USART, USART_PARITY_NONE); usart_set_flow_control(MEW_BLUETOOTH_USART, USART_FLOWCONTROL_NONE); usart_enable_rx_interrupt(MEW_BLUETOOTH_USART); usart_disable_tx_interrupt(MEW_BLUETOOTH_USART); usart_enable_tx_dma(MEW_BLUETOOTH_USART); usart_enable(MEW_BLUETOOTH_USART); nvic_enable_irq(MEW_BLUETOOTH_IRQ); nvic_enable_irq(MEW_BLUETOOTH_DMA_NVIC_TX); memset(_mew_bt_buffer, 0, MEW_BT_RECEIVE_BUFFER_SIZE); }
static void vga_gpio_setup ( void ) { /* Enable GPIO clock. */ rcc_peripheral_enable_clock ( &RCC_AHB1ENR, RCC_AHB1ENR_IOPBEN ); // hsync, vsync, vblank, vga out, pixel clock rcc_peripheral_enable_clock ( &RCC_AHB1ENR, RCC_AHB1ENR_IOPCEN ); // hsync, vsync, vblank, vga out, pixel clock // VGA // // sync lines gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO10 ); // vsync gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO11 ); // hsync gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 ); // vblank to CPU gpio_mode_setup ( GPIOB, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, GPIO13 ); // frameready from CPU // colour gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO0 ); // red gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO1 ); // red gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO2 ); // green gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO3 ); // green gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO4 ); // blue gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO5 ); // blue // speed gpio_set_output_options ( GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO10 | GPIO11 ); gpio_set_output_options ( GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO0 | GPIO1 | GPIO2 | GPIO3 | GPIO4 | GPIO5 ); // reset // gpio_set ( GPIOB, GPIO10 ); // vsync gpio_set ( GPIOB, GPIO11 ); // hsync gpio_clear ( GPIOC, GPIO0 | GPIO1 ); // red gpio_clear ( GPIOC, GPIO2 | GPIO3 ); // green gpio_clear ( GPIOC, GPIO4 | GPIO5 ); // blue }
void gpio_setup(void) { /* LED0, 1, 2 on PA4, PA5, PC13 TX, RX (MCU-side) on PA2, PA3 TGT_RST on PB13 TGT_SWDIO, TGT_SWCLK on PB15, PB14 TGT_SWO on PA10 */ /* Enable GPIOA, GPIOB, and GPIOC clocks. */ rcc_periph_clock_enable(RCC_GPIOA); rcc_periph_clock_enable(RCC_GPIOB); rcc_periph_clock_enable(RCC_GPIOC); /* Setup LEDs as open-drain outputs */ uint8_t otype = (LED_OPEN_DRAIN ? GPIO_OTYPE_OD : GPIO_OTYPE_PP); gpio_set_output_options(GPIOA, otype, GPIO_OSPEED_LOW, GPIO4 | GPIO5); gpio_set_output_options(GPIOC, otype, GPIO_OSPEED_LOW, GPIO13); gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO4 | GPIO5); gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO13); }
void platform_main(int arg) { rcc_clock_setup_hse(&clock_72mhz); rcc_periph_clock_enable(RCC_GPIOA); rcc_periph_clock_enable(RCC_GPIOB); // CAN pin gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIOA_CAN_RX | GPIOA_CAN_TX); gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIOA_CAN_RX | GPIOA_CAN_TX); gpio_set_af(GPIOA, GPIO_AF9, GPIOA_CAN_RX | GPIOA_CAN_TX); // enable CAN transceiver gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIOA_CAN_DIS); gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIOA_CAN_DIS); gpio_clear(GPIOA, GPIOA_CAN_DIS); // LED on gpio_mode_setup(GPIOA, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIOA_LED); gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIOA_LED); gpio_set(GPIOA, GPIOA_LED); // configure timeout of 10000 milliseconds timeout_timer_init(72000000, 10000); can_interface_init(); bootloader_main(arg); reboot_system(BOOT_ARG_START_BOOTLOADER); }
static void stmpe811_i2c_init() { rcc_periph_clock_enable(RCC_GPIOA); rcc_periph_clock_enable(RCC_GPIOC); rcc_periph_clock_enable(RCC_I2C3); gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8); gpio_set_output_options(GPIOA, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO8); gpio_set_af(GPIOA, GPIO_AF4, GPIO8); gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9); gpio_set_output_options(GPIOC, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO9); gpio_set_af(GPIOC, GPIO_AF4, GPIO9); i2c_peripheral_disable(I2C3); /* disable i2c during setup */ i2c_reset(I2C3); i2c_set_fast_mode(I2C3); i2c_set_clock_frequency(I2C3, I2C_CR2_FREQ_42MHZ); i2c_set_ccr(I2C3, 35); i2c_set_trise(I2C3, 43); i2c_peripheral_enable(I2C3); /* finally enable i2c */ i2c_set_own_7bit_slave_address(I2C3, 0x00); }
static void gpio_setup ( void ) { /* Enable GPIOC clock. */ rcc_peripheral_enable_clock ( &RCC_AHB1ENR, RCC_AHB1ENR_IOPBEN ); rcc_peripheral_enable_clock ( &RCC_AHB1ENR, RCC_AHB1ENR_IOPCEN ); /* Blinky LED: Set GPIO3 to 'output push-pull'. */ gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 ); // VGA // // sync lines gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO10 ); // vsync gpio_mode_setup ( GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO11 ); // hsync // colour gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO0 ); // red gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO1 ); // red gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO2 ); // green gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO3 ); // green gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO4 ); // blue gpio_mode_setup ( GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO5 ); // blue // speed gpio_set_output_options ( GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO10 | GPIO11 ); gpio_set_output_options ( GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO0 | GPIO1 | GPIO2 | GPIO3 | GPIO4 | GPIO5 ); // reset // gpio_set ( GPIOB, GPIO12 ); // LED gpio_set ( GPIOB, GPIO10 ); // vsync gpio_set ( GPIOB, GPIO11 ); // hsync gpio_clear ( GPIOC, GPIO0 | GPIO1 ); // red gpio_clear ( GPIOC, GPIO2 | GPIO3 ); // green gpio_clear ( GPIOC, GPIO4 | GPIO5 ); // blue }
void i2c3_hw_init(void) { i2c3.reg_addr = (void *)I2C3; i2c3.init_struct = NULL; i2c3.errors = &i2c3_errors; i2c3_watchdog_counter = 0; /* zeros error counter */ ZEROS_ERR_COUNTER(i2c3_errors); /* reset peripheral to default state ( sometimes not achieved on reset :( ) */ //i2c_reset(I2C3); /* Configure priority grouping 0 bits for pre-emption priority and 4 bits for sub-priority. */ scb_set_priority_grouping(SCB_AIRCR_PRIGROUP_NOGROUP_SUB16); /* Configure and enable I2C3 event interrupt --------------------------------*/ nvic_set_priority(NVIC_I2C3_EV_IRQ, 0); nvic_enable_irq(NVIC_I2C3_EV_IRQ); /* Configure and enable I2C3 err interrupt ----------------------------------*/ nvic_set_priority(NVIC_I2C3_ER_IRQ, 1); nvic_enable_irq(NVIC_I2C3_ER_IRQ); /* Enable peripheral clocks -------------------------------------------------*/ /* Enable I2C3 clock */ rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_I2C3EN); /* Enable GPIO clock */ gpio_enable_clock(I2C3_GPIO_SCL_PORT); gpio_mode_setup(I2C3_GPIO_SCL_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C3_GPIO_SCL); gpio_set_output_options(I2C3_GPIO_SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C3_GPIO_SCL); gpio_set_af(I2C3_GPIO_SCL_PORT, GPIO_AF4, I2C3_GPIO_SCL); gpio_enable_clock(I2C3_GPIO_SDA_PORT); gpio_mode_setup(I2C3_GPIO_SDA_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C3_GPIO_SDA); gpio_set_output_options(I2C3_GPIO_SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C3_GPIO_SDA); gpio_set_af(I2C3_GPIO_SDA_PORT, GPIO_AF4, I2C3_GPIO_SDA); i2c_reset(I2C3); // enable peripheral i2c_peripheral_enable(I2C3); /* * XXX: there is a function to do that already in libopencm3 but I am not * sure if it is correct, using direct register instead (esden) */ //i2c_set_own_7bit_slave_address(I2C3, 0); I2C_OAR1(I2C3) = 0 | 0x4000; // enable error interrupts I2C_CR2(I2C1) |= I2C_CR2_ITERREN; i2c_setbitrate(&i2c3, I2C3_CLOCK_SPEED); }
void candle_can_init(void) { rx_callback = 0; memset(led_status, 0, sizeof(led_status)); clear_tx_queue(0); clear_tx_queue(1); // enable led outputs rcc_periph_clock_enable(RCC_GPIOD); gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 | GPIO13 | GPIO14 | GPIO15); // enable can1 peripheral rcc_periph_clock_enable(RCC_GPIOD); rcc_periph_clock_enable(RCC_CAN1); gpio_mode_setup(GPIOD, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO0 | GPIO1); gpio_set_output_options(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO0 | GPIO1); gpio_set_af(GPIOD, GPIO_AF9, GPIO0 | GPIO1); reset_can(CAN1); init_can(CAN1); // enable can1 transceiver rcc_periph_clock_enable(RCC_GPIOC); gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO6); gpio_clear(GPIOC, GPIO6); // enable can2 peripheral rcc_periph_clock_enable(RCC_GPIOB); rcc_periph_clock_enable(RCC_CAN2); gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO12 | GPIO13); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO12 | GPIO13); gpio_set_af(GPIOB, GPIO_AF9, GPIO12 | GPIO13); reset_can(CAN2); init_can(CAN2); // enable can2 transceiver rcc_periph_clock_enable(RCC_GPIOD); gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO11); gpio_clear(GPIOD, GPIO11); // init filter banks CAN_FMR(CAN1) |= CAN_FMR_FINIT; // switch filter banks to init mode // configure usage of 14 filter banks for can1 and 14 banks for can2 CAN_FMR(CAN1) &= ~CAN_FMR_CAN2SB_MASK; CAN_FMR(CAN1) |= (14<<CAN_FMR_CAN2SB_SHIFT); can_filter_id_mask_32bit_init(CAN1, 0, 0, 0, 0, 1); // set a catch-all filter for CAN1 fifo 0 can_filter_id_mask_32bit_init(CAN2, 14, 0, 0, 0, 1); // set a catch-all filter for CAN2 fifo 0 CAN_FMR(CAN1) &= ~CAN_FMR_FINIT; // switch filter banks to active mode }
/*--------------------------------------------------------------------*/ void gpio_setup(void) { /* Clocks on AHB1 for GPIO D (LEDs) and C (monitor) */ rcc_periph_clock_enable(RCC_GPIOD); rcc_periph_clock_enable(RCC_GPIOC); /* Digital Test output PC1 */ gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO0 | GPIO1); gpio_set_output_options(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO0 | GPIO1); /* GPIO LED ports */ gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 | GPIO13 | GPIO14 | GPIO15); gpio_set_output_options(GPIOD, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO12 | GPIO13 | GPIO14 | GPIO15); }
static void board_init(void) { /* fix up the max firmware size, we have to read memory to get this */ board_info.fw_size = APP_SIZE_MAX, #ifdef INTERFACE_USB /* enable pin with a pulldown to sniff presence of cable */ rcc_peripheral_enable_clock(&BOARD_PRESENCE_CLOCK_REGISTER, BOARD_PRESENCE_CLOCK_BIT); gpio_mode_setup(BOARD_PRESENCE_PORT, GPIO_MODE_INPUT, BOARD_PRESENCE_PULL, BOARD_PRESENCE_PIN); #endif /* initialise LEDs */ rcc_peripheral_enable_clock(&RCC_AHB1ENR, BOARD_CLOCK_LEDS); gpio_mode_setup( BOARD_PORT_LEDS, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); gpio_set_output_options( BOARD_PORT_LEDS, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); BOARD_LED_ON ( BOARD_PORT_LEDS, BOARD_PIN_LED_BOOTLOADER | BOARD_PIN_LED_ACTIVITY); /* enable the power controller clock */ rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN); }
/* * pin_init_output() - Initialize GPIO for LED * * INPUT * - pin: pointer pin assignment * - output_mode: pin output state * - pull_mode: input mode * OUTPUT * none */ void pin_init_output(const Pin *pin, OutputMode output_mode, PullMode pull_mode) { uint8_t output_mode_setpoint; uint8_t pull_mode_setpoint; switch( output_mode ) { case OPEN_DRAIN_MODE: output_mode_setpoint = GPIO_OTYPE_OD; break; case PUSH_PULL_MODE: default: output_mode_setpoint = GPIO_OTYPE_PP; break; } switch( pull_mode ) { case PULL_UP_MODE: pull_mode_setpoint = GPIO_PUPD_PULLUP; break; case PULL_DOWN_MODE: pull_mode_setpoint = GPIO_PUPD_PULLDOWN; break; case NO_PULL_MODE: default: pull_mode_setpoint = GPIO_PUPD_NONE; break; } /* Set up port A */ gpio_mode_setup( pin->port, GPIO_MODE_OUTPUT, pull_mode_setpoint, pin->pin ); gpio_set_output_options( pin->port, output_mode_setpoint, GPIO_OSPEED_100MHZ, pin->pin ); }
/* Function to init EEPROM driver and I2C peripheral */ void eeprom_init(void) { /* Enable GPIOB clock. */ rcc_periph_clock_enable(RCC_GPIOB); /* set I2C1_SCL and I2C1_SDA, external pull-up resistors */ gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO6 | GPIO7); /* Open Drain, Speed 100 MHz */ gpio_set_output_options(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_100MHZ, GPIO6 | GPIO7); /* Alternate Function: I2C1 */ gpio_set_af(GPIOB, GPIO_AF4, GPIO6 | GPIO7); /* Enable I2C1 clock. */ rcc_periph_clock_enable(RCC_I2C1); /* Enable I2C1 interrupt. */ nvic_enable_irq(NVIC_I2C1_EV_IRQ); /* reset I2C1 */ i2c_reset(I2C1); /* standard mode */ i2c_set_standard_mode(I2C1); /* clock and bus frequencies */ i2c_set_clock_frequency(I2C1, I2C_CR2_FREQ_2MHZ); i2c_set_ccr(I2C1, 20); /* enable error event interrupt only */ i2c_enable_interrupt(I2C1, I2C_CR2_ITERREN); /* enable I2C */ i2c_peripheral_enable(I2C1); }
/* Initialize the SPI peripheral. */ void init_spi(void){ rcc_periph_clock_enable(RCC_SPI3); rcc_periph_clock_enable(RCC_GPIOB); gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO3 | GPIO4 | GPIO5); gpio_set_af(GPIOB, GPIO_AF6, GPIO3 | GPIO4 | GPIO5); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO3 | GPIO5); }
static void usart_setup(void) { /* Enable the USART2 interrupt. */ nvic_enable_irq(NVIC_USART2_IRQ); /* Setup GPIO pins for USART2 transmit. */ gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO2); /* Setup GPIO pins for USART2 receive. */ gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO3); gpio_set_output_options(GPIOA, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, GPIO3); /* Setup USART2 TX and RX pin as alternate function. */ gpio_set_af(GPIOA, GPIO_AF7, GPIO2); gpio_set_af(GPIOA, GPIO_AF7, GPIO3); /* Setup USART2 parameters. */ usart_set_baudrate(USART2, 38400); usart_set_databits(USART2, 8); usart_set_stopbits(USART2, USART_STOPBITS_1); usart_set_mode(USART2, USART_MODE_TX_RX); usart_set_parity(USART2, USART_PARITY_NONE); usart_set_flow_control(USART2, USART_FLOWCONTROL_NONE); /* Enable USART2 Receive interrupt. */ usart_enable_rx_interrupt(USART2); /* Finally enable the USART. */ usart_enable(USART2); }
static void mco_setup(void) { rcc_periph_clock_enable(RCC_GPIOA); gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8); gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8); gpio_set_af(GPIOA, GPIO_AF0, GPIO8); rcc_set_mco(RCC_CFGR_MCO_HSE); }
void spi_gpio_init(void) { /* SCK, MISO, MOSI */ gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, BL_SPI2_SCK | BL_SPI2_MISO | BL_SPI2_MOSI); gpio_set_af(GPIOB, GPIO_AF5, BL_SPI2_SCK | BL_SPI2_MISO | BL_SPI2_MOSI); /* WriteProtect and Reset */ gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_PULLUP, BL_SPI2_RST | BL_SPI2_WP); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, BL_SPI2_RST | BL_SPI2_WP); /* SPI select PIN(CS/NSS) */ gpio_mode_setup(GPIOB, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BL_SPI2_NSS); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, BL_SPI2_NSS); }
static void sound_init_gpio(void) { // set all gpio directions to output gpio_mode_setup(SPEAKER_GPIO, GPIO_MODE_AF, GPIO_PUPD_NONE, SPEAKER_PIN); gpio_set_output_options(SPEAKER_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SPEAKER_PIN); // connect TIM1 pins to AF2 on gpio gpio_set_af(SPEAKER_GPIO, GPIO_AF2, SPEAKER_PIN); }
void i2c2_hw_init(void) { i2c2.reg_addr = (void *)I2C2; i2c2.init_struct = NULL; i2c2.errors = &i2c2_errors; i2c2_watchdog_counter = 0; /* zeros error counter */ ZEROS_ERR_COUNTER(i2c2_errors); /* reset peripheral to default state ( sometimes not achieved on reset :( ) */ //i2c_reset(I2C2); /* Configure and enable I2C2 event interrupt --------------------------------*/ nvic_set_priority(NVIC_I2C2_EV_IRQ, NVIC_I2C2_IRQ_PRIO); nvic_enable_irq(NVIC_I2C2_EV_IRQ); /* Configure and enable I2C2 err interrupt ----------------------------------*/ nvic_set_priority(NVIC_I2C2_ER_IRQ, NVIC_I2C2_IRQ_PRIO+1); nvic_enable_irq(NVIC_I2C2_ER_IRQ); /* Enable peripheral clocks -------------------------------------------------*/ /* Enable I2C2 clock */ rcc_periph_clock_enable(RCC_I2C2); /* Enable GPIO clock */ gpio_enable_clock(I2C2_GPIO_PORT); #if defined(STM32F1) gpio_set_mode(I2C2_GPIO_PORT, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_OPENDRAIN, I2C2_GPIO_SCL | I2C2_GPIO_SDA); #elif defined(STM32F4) gpio_mode_setup(I2C2_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C2_GPIO_SCL | I2C2_GPIO_SDA); gpio_set_output_options(I2C2_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C2_GPIO_SCL | I2C2_GPIO_SDA); gpio_set_af(I2C2_GPIO_PORT, GPIO_AF4, I2C2_GPIO_SCL | I2C2_GPIO_SDA); #endif i2c_reset(I2C2); // enable peripheral i2c_peripheral_enable(I2C2); /* * XXX: there is a function to do that already in libopencm3 but I am not * sure if it is correct, using direct register instead (esden) */ //i2c_set_own_7bit_slave_address(I2C2, 0); I2C_OAR1(I2C2) = 0 | 0x4000; // enable error interrupts I2C_CR2(I2C1) |= I2C_CR2_ITERREN; i2c_setbitrate(&i2c2, I2C2_CLOCK_SPEED); }
static void led_init() { RCC_APB1ENR |= RCC_APB1ENR_TIM3EN; RCC_AHBENR |= RCC_AHBENR_GPIOBEN; gpio_mode_setup(LED_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LED_R_PIN | LED_G_PIN | LED_B_PIN); gpio_set_output_options(LED_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_25MHZ, LED_R_PIN | LED_G_PIN | LED_B_PIN); setupPWM(); }
static bool board_test_force_pin() { #if defined(BOARD_FORCE_BL_PIN_IN) && defined(BOARD_FORCE_BL_PIN_OUT) /* two pins strapped together */ volatile unsigned samples = 0; volatile unsigned vote = 0; /* (re)configure the force BL pins */ rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT); gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN_IN); gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT); gpio_set_output_options(BOARD_FORCE_BL_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, BOARD_FORCE_BL_PIN_OUT); for (volatile unsigned cycles = 0; cycles < 10; cycles++) { gpio_set(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN_OUT); for (unsigned count = 0; count < 20; count++) { if (gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN_IN) != 0) vote++; samples++; } gpio_clear(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN_OUT); for (unsigned count = 0; count < 20; count++) { if (gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN_IN) == 0) vote++; samples++; } } /* revert the driver pin */ gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, BOARD_FORCE_BL_PIN_OUT); /* the idea here is to reject wire-to-wire coupling, so require > 90% agreement */ if ((vote * 100) > (samples * 90)) return true; #endif #if defined(BOARD_FORCE_BL_PIN) /* single pin pulled up or down */ volatile unsigned samples = 0; volatile unsigned vote = 0; /* (re)configure the force BL pins */ rcc_peripheral_enable_clock(&BOARD_FORCE_BL_CLOCK_REGISTER, BOARD_FORCE_BL_CLOCK_BIT); gpio_mode_setup(BOARD_FORCE_BL_PORT, GPIO_MODE_INPUT, BOARD_FORCE_BL_PULL, BOARD_FORCE_BL_PIN); for (samples = 0; samples < 200; samples++) { if ((gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN) ? 1 : 0) == BOARD_FORCE_BL_STATE) vote++; } /* reject a little noise */ if ((vote * 100) > (samples * 90)) return true; #endif return false; }
static void i2c_setup_gpio(uint32_t i2c) { switch (i2c) { #if USE_I2C1 case I2C1: gpio_enable_clock(I2C1_GPIO_PORT); gpio_mode_setup(I2C1_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C1_GPIO_SCL | I2C1_GPIO_SDA); gpio_set_output_options(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C1_GPIO_SCL | I2C1_GPIO_SDA); gpio_set_af(I2C1_GPIO_PORT, GPIO_AF4, I2C1_GPIO_SCL | I2C1_GPIO_SDA); break; #endif #if USE_I2C2 case I2C2: gpio_enable_clock(I2C2_GPIO_PORT); gpio_mode_setup(I2C2_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C2_GPIO_SCL | I2C2_GPIO_SDA); gpio_set_output_options(I2C2_GPIO_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C2_GPIO_SCL | I2C2_GPIO_SDA); gpio_set_af(I2C2_GPIO_PORT, GPIO_AF4, I2C2_GPIO_SCL | I2C2_GPIO_SDA); break; #endif #if USE_I2C3 case I2C3: gpio_enable_clock(I2C3_GPIO_PORT_SCL); gpio_mode_setup(I2C3_GPIO_PORT_SCL, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C3_GPIO_SCL); gpio_set_output_options(I2C3_GPIO_PORT_SCL, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C3_GPIO_SCL); gpio_set_af(I2C3_GPIO_PORT_SCL, GPIO_AF4, I2C3_GPIO_SCL); gpio_enable_clock(I2C3_GPIO_PORT_SDA); gpio_mode_setup(I2C3_GPIO_PORT_SDA, GPIO_MODE_AF, GPIO_PUPD_NONE, I2C3_GPIO_SDA); gpio_set_output_options(I2C3_GPIO_PORT_SDA, GPIO_OTYPE_OD, GPIO_OSPEED_25MHZ, I2C3_GPIO_SDA); gpio_set_af(I2C3_GPIO_PORT_SDA, GPIO_AF4, I2C3_GPIO_SDA); break; #endif default: break; } }
static void mco_setup(void) { /* PA8 to AF 0 for MCO */ rcc_periph_clock_enable(RCC_GPIOA); gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8); gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8); gpio_set_af(GPIOA, 0, GPIO8); /* clock output on pin PA8 (allows checking with scope) */ rcc_set_mco(RCC_CFGR_MCO_SYSCLK); }
/*--------------------------------------------------------------------*/ static void gpio_setup(void) { /* Port A and C are on AHB1 */ rcc_periph_clock_enable(RCC_GPIOA); rcc_periph_clock_enable(RCC_GPIOC); /* Set the digital test output on PC1 */ gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO1); gpio_set_output_options(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_2MHZ, GPIO1); /* Set PA4 for DAC channel 1 to analogue, ignoring drive mode. */ gpio_mode_setup(GPIOA, GPIO_MODE_ANALOG, GPIO_PUPD_NONE, GPIO4); }
/** * Initializes the clocks and GPIOS for the LEDs to work. */ static void led_init(void) { rcc_periph_clock_enable(RCC_GPIOC); gpio_mode_setup(GPIOC, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, led_pin_lut[LED1] | led_pin_lut[LED2] | led_pin_lut[LED3] | led_pin_lut[LED4]); gpio_set_output_options(GPIOC, GPIO_OTYPE_PP, GPIO_OSPEED_LOW, led_pin_lut[LED1] | led_pin_lut[LED2] | led_pin_lut[LED3] | led_pin_lut[LED4]); }
/* * usart_init() - Initialize USART Debug Port * * INPUT * none * OUTPUT * none */ void usart_init(void) { /* Setup PB10 for USART-TX */ gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO10); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO10); /* Setup PB11 for USART-RX */ gpio_mode_setup(GPIOB, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO11); gpio_set_output_options(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, GPIO11); /* Set PB10 and PB11 to USART3 alternate aunction */ gpio_set_af(GPIOB, 7, GPIO10); gpio_set_af(GPIOB, 7, GPIO11); /*enable USART3 clock source */ rcc_periph_clock_enable(RCC_USART3); /* disable USART3 before you are allow to write to USART3 registers */ usart_disable(USART3_BASE) ; /* set Word Length */ usart_set_databits(USART3_BASE, 8); /* Set Transmit/Receive mode */ usart_set_mode(USART3_BASE, USART_CR1_RE | USART_CR1_TE); usart_set_stopbits(USART3_BASE, USART_CR2_STOPBITS_1); /* disable parity */ usart_set_parity(USART3_BASE, 0); /* USART_CR1_PCE */ usart_set_flow_control(USART3_BASE, 0); usart_set_baudrate(USART3_BASE, 115200); /* enable USART */ usart_enable(USART3_BASE); /* Note : RDR= Read data, TDR=Transmit data */ }
static void lcd_init_gpio(void) { // set all gpio directions to output // set powerdown trigger pin as output // data lines D0..D7 gpio_mode_setup(LCD_DATA_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, 0xFF); gpio_set_output_options(LCD_DATA_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, 0xFF); // rw gpio_mode_setup(LCD_RW_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LCD_RW_PIN); gpio_set_output_options(LCD_RW_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LCD_RW_PIN); // rst gpio_mode_setup(LCD_RST_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LCD_RST_PIN); gpio_set_output_options(LCD_RST_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LCD_RST_PIN); // rs gpio_mode_setup(LCD_RS_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LCD_RS_PIN); gpio_set_output_options(LCD_RS_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LCD_RS_PIN); // rd gpio_mode_setup(LCD_RD_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LCD_RD_PIN); gpio_set_output_options(LCD_RD_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LCD_RD_PIN); // cs gpio_mode_setup(LCD_CS_GPIO, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, LCD_CS_PIN); gpio_set_output_options(LCD_CS_GPIO, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, LCD_CS_PIN); // set default pin levels: LCD_RST_LO(); LCD_CS_HI(); LCD_RW_LO(); LCD_RD_HI(); LCD_RS_HI(); }
/* Function to setup all used GPIOs */ static void gpio_setup(void) { /* Enable GPIOD clock. */ rcc_periph_clock_enable(RCC_GPIOD); /* Set GPIO12/13/14/15 (in GPIO port D) to 'output push-pull'. */ gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO12 | GPIO13 | GPIO14 | GPIO15); /* LIS3DSH pins map: PA5 - SPI1_SCK PA6 - SPI1_MISO PA7 - SPI1_MOSI PE3 - CS_SPI */ /* Enable GPIOA clock. */ rcc_periph_clock_enable(RCC_GPIOA); /* set SPI pins as CLK, MOSI, MISO */ gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO5 | GPIO6 | GPIO7); /* Push Pull, Speed 100 MHz */ gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO5 | GPIO6 | GPIO7); /* Alternate Function: SPI1 */ gpio_set_af(GPIOA, GPIO_AF5, GPIO5 | GPIO6 | GPIO7); /* Enable GPIOE clock. */ rcc_periph_clock_enable(RCC_GPIOE); /* set CS as OUTPUT */ gpio_mode_setup(GPIOE, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO3); /* Push Pull, Speed 100 MHz */ gpio_set_output_options(GPIOE, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO3); /* set CS high */ gpio_set(GPIOE, GPIO3); }
void mew_spi_flash_init(void) { gpio_mode_setup(MEW_FLASH_GPIO_PORT_WP, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, MEW_FLASH_GPIO_PIN_WP); gpio_set_output_options(MEW_FLASH_GPIO_PORT_WP, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_FLASH_GPIO_PIN_WP); gpio_set(MEW_FLASH_GPIO_PORT_WP, MEW_FLASH_GPIO_PIN_WP); gpio_mode_setup(MEW_FLASH_GPIO_PORT_HOLD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, MEW_FLASH_GPIO_PIN_HOLD); gpio_set_output_options(MEW_FLASH_GPIO_PORT_HOLD, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_FLASH_GPIO_PIN_HOLD); gpio_set(MEW_FLASH_GPIO_PORT_HOLD, MEW_FLASH_GPIO_PIN_HOLD); gpio_mode_setup(MEW_FLASH_GPIO_PORT_CS, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, MEW_FLASH_GPIO_PIN_CS); gpio_set_output_options(MEW_FLASH_GPIO_PORT_CS, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_FLASH_GPIO_PIN_CS); gpio_set(MEW_FLASH_GPIO_PORT_CS, MEW_FLASH_GPIO_PIN_CS); gpio_mode_setup(MEW_FLASH_SPI_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_PULLDOWN, MEW_FLASH_SPI_GPIO_PINS); gpio_set_output_options(MEW_FLASH_SPI_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, MEW_FLASH_SPI_GPIO_PINS); gpio_set_af(MEW_FLASH_SPI_GPIO_PORT, MEW_FLASH_SPI_GPIO_AF_NUMBER, MEW_FLASH_SPI_GPIO_PINS); spi_disable(MEW_FLASH_SPI); spi_set_master_mode(MEW_FLASH_SPI); spi_set_baudrate_prescaler(MEW_FLASH_SPI, SPI_CR1_BR_FPCLK_DIV_2); spi_set_clock_polarity_0(MEW_FLASH_SPI); spi_set_clock_phase_0(MEW_FLASH_SPI); spi_set_unidirectional_mode(MEW_FLASH_SPI); spi_enable_software_slave_management(MEW_FLASH_SPI); spi_send_msb_first(MEW_FLASH_SPI); spi_set_nss_high(MEW_FLASH_SPI); SPI_I2SCFGR(MEW_FLASH_SPI) &= ~SPI_I2SCFGR_I2SMOD; spi_disable_tx_buffer_empty_interrupt(MEW_FLASH_SPI); spi_disable_rx_buffer_not_empty_interrupt(MEW_FLASH_SPI); spi_disable_error_interrupt(MEW_FLASH_SPI); spi_disable_tx_dma(MEW_FLASH_SPI); spi_disable_rx_dma(MEW_FLASH_SPI); spi_set_dff_8bit(MEW_FLASH_SPI); spi_send_msb_first(MEW_FLASH_SPI); spi_enable(MEW_FLASH_SPI); }
void setupPWM() { gpio_mode_setup(LED_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, LED_R_PIN | LED_G_PIN); gpio_set_output_options(LED_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_25MHZ, LED_R_PIN | LED_G_PIN); gpio_set_af(LED_PORT, GPIO_AF1, LED_R_PIN | LED_G_PIN); TIM_CCMR1(RGB_TIMER) = TIM_CCMR1_OC1M_PWM1 | TIM_CCMR1_OC2M_PWM1; TIM_CCER(RGB_TIMER) = TIM_CCER_CC1E | TIM_CCER_CC2E; TIM_PSC(RGB_TIMER) = 1000; TIM_ARR(RGB_TIMER) = 0xff; TIM_CR1(RGB_TIMER) = TIM_CR1_CEN; g_isRedBlinking = false; setLEDColor(127, 127, 0); }