/*
* 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);
}
