bsp_stm32f4_discovery.c

#if defined (BOARD_STM32F4_DISCOVERY)
#include "heivs/config.h"
#include "heivs/bsp.h"
#include "heivs/time.h"
#include "heivs/delay.h"
#include "heivs/retarget.h"
#include "stm32/usb/usb_core.h"
#include "stm32/stm32f4xx_rcc.h"

static void bsp_pwm_leds_init(uint32_t frequency, uint32_t steps, uint32_t initial)
{
    const struct gpio_t pins[] =
    {
            GPIO_TIM4_CH1_PD12,
            GPIO_TIM4_CH2_PD13,
            GPIO_TIM4_CH3_PD14,
            GPIO_TIM4_CH4_PD15,
    };

    /* Pin setup */
    gpio_setup_list(pins, ARRAY_SIZE(pins));

    /* Enable the timer clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

    /* Reset the timer */
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_TIM4, DISABLE);

    TIM4->CCER =
              TIM_CCER_CC1E
            | TIM_CCER_CC2E
            | TIM_CCER_CC3E
            | TIM_CCER_CC4E
        ;

    /**
     * Timer frequency = steps * input_frequency
     */
    TIM4->PSC = (((SystemClock.timer)/steps)/frequency) - 1;

    /**
     * Count steps (from zero to steps - 1)
     */
    TIM4->ARR = steps - 1;

    /* Set the output value to 50 % */
    TIM4->CCR1 = initial;
    TIM4->CCR2 = initial;
    TIM4->CCR3 = initial;
    TIM4->CCR4 = initial;

    TIM4->CCMR1 =
                TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1 | TIM_CCMR1_OC1PE
              | TIM_CCMR1_OC2M_2 | TIM_CCMR1_OC2M_1 | TIM_CCMR1_OC2PE;
        ;
    TIM4->CCMR2 =
                TIM_CCMR2_OC3M_2 | TIM_CCMR2_OC3M_1 | TIM_CCMR2_OC3PE
              | TIM_CCMR2_OC4M_2 | TIM_CCMR2_OC4M_1 | TIM_CCMR2_OC4PE
        ;

    /* Update registers now */
    TIM4->EGR |= TIM_EGR_UG;

    /* Start the timer */
    TIM4->CR1 = TIM_CR1_ARPE | TIM_CR1_CEN;
}

void bsp_led_set_pwm(uint32_t nr, uint32_t value)
{
    if (nr < 4)
    {
        volatile uint32_t *addr[] =
        {
                &TIM4->CCR1,
                &TIM4->CCR3,
                &TIM4->CCR4,
                &TIM4->CCR2,
        };

        *addr[nr] = value;
    }
}

void bsp_led_set(uint32_t nr, uint32_t value)
{
    bsp_led_set_pwm(nr, value > 0 ? 255 : 0);
}

void bsp_led_toggle(uint32_t nr)
{
    if (nr < 4)
    {
        volatile uint32_t *addr[] =
        {
                &TIM4->CCR1,
                &TIM4->CCR3,
                &TIM4->CCR4,
                &TIM4->CCR2,
        };

        if (*addr[nr])
        {
            *addr[nr] = 0;
        }
        else
        {
            *addr[nr] = 255;
        }
    }
}

static const struct gpio_t bsp_buttons[BSP_BUTTON_NR] =
{
    DEF_GPIOA( 0, GPIO_INPUT | GPIO_PULLUP | GPIO_SPEED_2),
};

static status_e bsp_buttons_init(void)
{
    gpio_setup_list(bsp_buttons, ARRAY_SIZE(bsp_buttons));

    return NO_ERROR;
}

const struct gpio_t *bsp_button_gpios(void)
{
    return &bsp_buttons[0];
}

status_e bsp_init(void)
{
    status_e status;

    time_init();

    bsp_pwm_leds_init(50, BSP_PWM_LED_STEPS, 150);

    retarget_init();

    status = bsp_buttons_init();
    if (status != NO_ERROR)
    {
        return status;
    }

    return NO_ERROR;
}

uint32_t bsp_button_get(uint32_t nr)
{
    if (nr >= BSP_BUTTON_NR)
    {
        return 0;
    }

    return gpio_get(&bsp_buttons[nr]);
}

#if (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE)

static const struct gpio_t gpio_vbus_not = DEF_GPIOC( 0, GPIO_OUTPUT_1);

void USB_OTG_BSP_DriveVBUS(USB_OTG_CORE_HANDLE *pdev, uint8_t state)
{
    gpio_set(&gpio_vbus_not, !state);
}

void  USB_OTG_BSP_ConfigVBUS(USB_OTG_CORE_HANDLE *pdev)
{
    gpio_setup(&gpio_vbus_not);
    /* By Default, DISABLE is needed on output of the Power Switch */
    USB_OTG_BSP_DriveVBUS (pdev, 0);

    delay_wait_ms(200);   /* Delay is need for stabilising the Vbus Low
    in Reset Condition, when Vbus=1 and Reset-button is pressed by user */
}
#endif /* (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE) */

#endif