ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[NUCLEO_F103RB] Update all hal files (STM32Cube compliancy)

pull/953/head
bcostm 2015-03-06 10:11:35 +01:00
parent d54b1038fa
commit ba2d69e5a4
17 changed files with 868 additions and 689 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/PeripheralPins.c
View File

@ -39,38 +39,38 @@
//*** ADC *** //*** ADC ***
const PinMap PinMap_ADC[] = { const PinMap PinMap_ADC[] = {
{PA_0, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN0 {PA_0, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN0
{PA_1, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN1 {PA_1, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN1
{PA_2, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN2 {PA_2, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN2
{PA_3, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN3 {PA_3, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN3
{PA_4, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN4 {PA_4, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN4
{PA_5, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN5 {PA_5, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN5
{PA_6, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN6 {PA_6, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN6
{PA_7, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN7 {PA_7, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN7
{PB_0, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN8 {PB_0, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN8
{PB_1, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN9 {PB_1, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN9
{PC_0, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN10 {PC_0, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN10
{PC_1, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN11 {PC_1, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN11
{PC_2, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN12 {PC_2, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN12
{PC_3, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN13 {PC_3, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN13
{PC_4, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN14 {PC_4, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN14
{PC_5, ADC_1, STM_PIN_DATA(GPIO_Mode_AIN, 0)}, // ADC12_IN15 {PC_5, ADC_1, STM_PIN_DATA(STM_MODE_ANALOG, GPIO_NOPULL, 0)}, // ADC12_IN15
{NC, NC, 0} {NC, NC, 0}
}; };
//*** I2C *** //*** I2C ***
const PinMap PinMap_I2C_SDA[] = { const PinMap PinMap_I2C_SDA[] = {
{PB_7, I2C_1, STM_PIN_DATA(GPIO_Mode_AF_OD, 0)}, {PB_7, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 0)},
{PB_9, I2C_1, STM_PIN_DATA(GPIO_Mode_AF_OD, 2)}, // GPIO_Remap_I2C1 {PB_9, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 2)}, // GPIO_Remap_I2C1
{PB_11, I2C_2, STM_PIN_DATA(GPIO_Mode_AF_OD, 0)}, {PB_11, I2C_2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };
const PinMap PinMap_I2C_SCL[] = { const PinMap PinMap_I2C_SCL[] = {
{PB_6, I2C_1, STM_PIN_DATA(GPIO_Mode_AF_OD, 0)}, {PB_6, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 0)},
{PB_8, I2C_1, STM_PIN_DATA(GPIO_Mode_AF_OD, 2)}, // GPIO_Remap_I2C1 {PB_8, I2C_1, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 2)}, // GPIO_Remap_I2C1
{PB_10, I2C_2, STM_PIN_DATA(GPIO_Mode_AF_OD, 0)}, {PB_10, I2C_2, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };
@ -78,88 +78,88 @@ const PinMap PinMap_I2C_SCL[] = {
// TIM4 cannot be used because already used by the us_ticker // TIM4 cannot be used because already used by the us_ticker
const PinMap PinMap_PWM[] = { const PinMap PinMap_PWM[] = {
{PA_1, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM2_CH2 - Default {PA_1, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM2_CH2 - Default
{PA_2, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM2_CH3 - Default (warning: not connected on D1 per default) {PA_2, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM2_CH3 - Default (warning: not connected on D1 per default)
{PA_3, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM2_CH4 - Default (warning: not connected on D0 per default) {PA_3, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM2_CH4 - Default (warning: not connected on D0 per default)
{PA_6, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM3_CH1 - Default {PA_6, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM3_CH1 - Default
{PA_7, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM3_CH2 - Default {PA_7, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM3_CH2 - Default
// {PA_7, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 6)}, // TIM1_CH1N - GPIO_PartialRemap_TIM1 // {PA_7, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 6)}, // TIM1_CH1N - GPIO_PartialRemap_TIM1
{PA_8, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH1 - Default {PA_8, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH1 - Default
{PA_9, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH2 - Default {PA_9, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH2 - Default
{PA_10, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH3 - Default {PA_10, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH3 - Default
{PA_11, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH4 - Default {PA_11, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH4 - Default
{PA_15, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 8)}, // TIM2_CH1_ETR - GPIO_FullRemap_TIM2 {PA_15, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 8)}, // TIM2_CH1_ETR - GPIO_FullRemap_TIM2
{PB_0, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM3_CH3 - Default {PB_0, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM3_CH3 - Default
// {PB_0, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 6)}, // TIM1_CH2N - GPIO_PartialRemap_TIM1 // {PB_0, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 6)}, // TIM1_CH2N - GPIO_PartialRemap_TIM1
{PB_1, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM3_CH4 - Default {PB_1, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM3_CH4 - Default
// {PB_1, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 6)}, // TIM1_CH3N - GPIO_PartialRemap_TIM1 // {PB_1, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 6)}, // TIM1_CH3N - GPIO_PartialRemap_TIM1
{PB_3, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 8)}, // TIM2_CH2 - GPIO_FullRemap_TIM2 {PB_3, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 8)}, // TIM2_CH2 - GPIO_FullRemap_TIM2
{PB_4, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 7)}, // TIM3_CH1 - GPIO_PartialRemap_TIM3 {PB_4, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 7)}, // TIM3_CH1 - GPIO_PartialRemap_TIM3
{PB_5, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 7)}, // TIM3_CH2 - GPIO_PartialRemap_TIM3 {PB_5, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 7)}, // TIM3_CH2 - GPIO_PartialRemap_TIM3
// {PB_6, PWM_4, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM4_CH1 - Default (used by ticker) // {PB_6, PWM_4, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM4_CH1 - Default (used by ticker)
// {PB_7, PWM_4, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM4_CH2 - Default (used by ticker) // {PB_7, PWM_4, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM4_CH2 - Default (used by ticker)
// {PB_8, PWM_4, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM4_CH3 - Default (used by ticker) // {PB_8, PWM_4, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM4_CH3 - Default (used by ticker)
// {PB_9, PWM_4, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM4_CH4 - Default (used by ticker) // {PB_9, PWM_4, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM4_CH4 - Default (used by ticker)
{PB_10, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 8)}, // TIM2_CH3 - GPIO_FullRemap_TIM2 {PB_10, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 8)}, // TIM2_CH3 - GPIO_FullRemap_TIM2
{PB_11, PWM_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 8)}, // TIM2_CH4 - GPIO_FullRemap_TIM2 {PB_11, PWM_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 8)}, // TIM2_CH4 - GPIO_FullRemap_TIM2
{PB_13, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH1N - Default {PB_13, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH1N - Default
{PB_14, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH2N - Default {PB_14, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH2N - Default
{PB_15, PWM_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, // TIM1_CH3N - Default {PB_15, PWM_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)}, // TIM1_CH3N - Default
{PC_6, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 9)}, // TIM3_CH1 - GPIO_FullRemap_TIM3 {PC_6, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 9)}, // TIM3_CH1 - GPIO_FullRemap_TIM3
{PC_7, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 9)}, // TIM3_CH2 - GPIO_FullRemap_TIM3 {PC_7, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 9)}, // TIM3_CH2 - GPIO_FullRemap_TIM3
{PC_8, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 9)}, // TIM3_CH3 - GPIO_FullRemap_TIM3 {PC_8, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 9)}, // TIM3_CH3 - GPIO_FullRemap_TIM3
{PC_9, PWM_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 9)}, // TIM3_CH4 - GPIO_FullRemap_TIM3 {PC_9, PWM_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 9)}, // TIM3_CH4 - GPIO_FullRemap_TIM3
{NC, NC, 0} {NC, NC, 0}
}; };
//*** SERIAL *** //*** SERIAL ***
const PinMap PinMap_UART_TX[] = { const PinMap PinMap_UART_TX[] = {
{PA_2, UART_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_2, UART_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)},
{PA_9, UART_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_9, UART_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)},
{PB_6, UART_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 3)}, // GPIO_Remap_USART1 {PB_6, UART_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 3)}, // GPIO_Remap_USART1
{PB_10, UART_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PB_10, UART_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 0)},
{PC_10, UART_3, STM_PIN_DATA(GPIO_Mode_AF_PP, 5)}, // GPIO_PartialRemap_USART3 {PC_10, UART_3, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_PULLUP, 5)}, // GPIO_PartialRemap_USART3
{NC, NC, 0} {NC, NC, 0}
}; };
const PinMap PinMap_UART_RX[] = { const PinMap PinMap_UART_RX[] = {
{PA_3, UART_2, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)}, {PA_3, UART_2, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLUP, 0)},
{PA_10, UART_1, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)}, {PA_10, UART_1, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLUP, 0)},
{PB_7, UART_1, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 3)}, // GPIO_Remap_USART1 {PB_7, UART_1, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLUP, 3)}, // GPIO_Remap_USART1
{PB_11, UART_3, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)}, {PB_11, UART_3, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLUP, 0)},
{PC_11, UART_3, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 5)}, // GPIO_PartialRemap_USART3 {PC_11, UART_3, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLUP, 5)}, // GPIO_PartialRemap_USART3
{NC, NC, 0} {NC, NC, 0}
}; };
//*** SPI *** //*** SPI ***
const PinMap PinMap_SPI_MOSI[] = { const PinMap PinMap_SPI_MOSI[] = {
{PA_7, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_7, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{PB_5, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 1)}, // GPIO_Remap_SPI1 {PB_5, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 1)}, // GPIO_Remap_SPI1
{PB_15, SPI_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PB_15, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };
const PinMap PinMap_SPI_MISO[] = { const PinMap PinMap_SPI_MISO[] = {
{PA_6, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_6, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{PB_4, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 1)}, // GPIO_Remap_SPI1 {PB_4, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 1)}, // GPIO_Remap_SPI1
{PB_14, SPI_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PB_14, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };
const PinMap PinMap_SPI_SCLK[] = { const PinMap PinMap_SPI_SCLK[] = {
{PA_5, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_5, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{PB_3, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 1)}, // GPIO_Remap_SPI1 {PB_3, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 1)}, // GPIO_Remap_SPI1
{PB_13, SPI_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PB_13, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };
const PinMap PinMap_SPI_SSEL[] = { const PinMap PinMap_SPI_SSEL[] = {
{PA_4, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PA_4, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{PA_15, SPI_1, STM_PIN_DATA(GPIO_Mode_AF_PP, 1)}, // GPIO_Remap_SPI1 {PA_15, SPI_1, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 1)}, // GPIO_Remap_SPI1
{PB_12, SPI_2, STM_PIN_DATA(GPIO_Mode_AF_PP, 0)}, {PB_12, SPI_2, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, 0)},
{NC, NC, 0} {NC, NC, 0}
}; };

23
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/PinNames.h
View File

@ -36,11 +36,24 @@
extern "C" { extern "C" {
#endif #endif
// MODE (see GPIOMode_TypeDef structure) // See stm32f3xx_hal_gpio.h and stm32f3xx_hal_gpio_ex.h for values of MODE, PUPD and AFNUM
// AFNUM (see AF_mapping constant table) #define STM_PIN_DATA(MODE, PUPD, AFNUM) ((int)(((AFNUM) << 7) | ((PUPD) << 4) | ((MODE) << 0)))
#define STM_PIN_DATA(MODE, AFNUM) (((MODE) << 8) | (AFNUM)) #define STM_PIN_MODE(X) (((X) >> 0) & 0x0F)
#define STM_PIN_MODE(X) ((X) >> 8) #define STM_PIN_PUPD(X) (((X) >> 4) & 0x07)
#define STM_PIN_AFNUM(X) ((X) & 0xFF) #define STM_PIN_AFNUM(X) (((X) >> 7) & 0x0F)
#define STM_MODE_INPUT (0)
#define STM_MODE_OUTPUT_PP (1)
#define STM_MODE_OUTPUT_OD (2)
#define STM_MODE_AF_PP (3)
#define STM_MODE_AF_OD (4)
#define STM_MODE_ANALOG (5)
#define STM_MODE_IT_RISING (6)
#define STM_MODE_IT_FALLING (7)
#define STM_MODE_IT_RISING_FALLING (8)
#define STM_MODE_EVT_RISING (9)
#define STM_MODE_EVT_FALLING (10)
#define STM_MODE_EVT_RISING_FALLING (11)
#define STM_MODE_IT_EVT_RESET (12)
// High nibble = port number (0=A, 1=B, 2=C, 3=D, 4=E, 5=F, 6=G, 7=H) // High nibble = port number (0=A, 1=B, 2=C, 3=D, 4=E, 5=F, 6=G, 7=H)
// Low nibble = pin number // Low nibble = pin number

103
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/analogin_api.c
View File

@ -30,17 +30,18 @@
#if DEVICE_ANALOGIN #if DEVICE_ANALOGIN
#include "wait_api.h"
#include "cmsis.h" #include "cmsis.h"
#include "pinmap.h" #include "pinmap.h"
#include "wait_api.h"
#include "PeripheralPins.h" #include "PeripheralPins.h"
ADC_HandleTypeDef AdcHandle;
int adc_inited = 0; int adc_inited = 0;
void analogin_init(analogin_t *obj, PinName pin) void analogin_init(analogin_t *obj, PinName pin)
{ {
ADC_TypeDef *adc; RCC_PeriphCLKInitTypeDef PeriphClkInit;
ADC_InitTypeDef ADC_InitStructure;
// Get the peripheral name from the pin and assign it to the object // Get the peripheral name from the pin and assign it to the object
obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC);
@ -56,101 +57,105 @@ void analogin_init(analogin_t *obj, PinName pin)
if (adc_inited == 0) { if (adc_inited == 0) {
adc_inited = 1; adc_inited = 1;
// Get ADC registers structure address // Enable ADC clock
adc = (ADC_TypeDef *)(obj->adc); __HAL_RCC_ADC1_CLK_ENABLE();
// Enable ADC clock (14 MHz maximum) // Configure ADC clock prescaler
// PCLK2 = 64 MHz --> ADC clock = 64/6 = 10.666 MHz // Caution: On STM32F1, ADC clock frequency max is 14 MHz (refer to device datasheet).
RCC_ADCCLKConfig(RCC_PCLK2_Div6); // Therefore, ADC clock prescaler must be configured in function
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); // of ADC clock source frequency to remain below this maximum frequency.
// with 8 MHz external xtal: PCLK2 = 72 MHz --> ADC clock = 72/6 = 12 MHz
// with internal clock : PCLK2 = 64 MHz --> ADC clock = 64/6 = 10.67 MHz
PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC;
PeriphClkInit.AdcClockSelection = RCC_ADCPCLK2_DIV6;
HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);
// Configure ADC // Configure ADC
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent; AdcHandle.Instance = (ADC_TypeDef *)(obj->adc);
ADC_InitStructure.ADC_ScanConvMode = DISABLE; AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE; AdcHandle.Init.ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; AdcHandle.Init.ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; AdcHandle.Init.NbrOfConversion = 1;
ADC_InitStructure.ADC_NbrOfChannel = 1; AdcHandle.Init.DiscontinuousConvMode = DISABLE;
ADC_Init(adc, &ADC_InitStructure); AdcHandle.Init.NbrOfDiscConversion = 0;
AdcHandle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
// Enable ADC HAL_ADC_Init(&AdcHandle);
ADC_Cmd(adc, ENABLE);
// Calibrate ADC
ADC_ResetCalibration(adc);
while (ADC_GetResetCalibrationStatus(adc));
ADC_StartCalibration(adc);
while (ADC_GetCalibrationStatus(adc));
} }
} }
static inline uint16_t adc_read(analogin_t *obj) static inline uint16_t adc_read(analogin_t *obj)
{ {
// Get ADC registers structure address ADC_ChannelConfTypeDef sConfig;
ADC_TypeDef *adc = (ADC_TypeDef *)(obj->adc);
int channel = 0; AdcHandle.Instance = (ADC_TypeDef *)(obj->adc);
// Configure ADC channel // Configure ADC channel
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_7CYCLES_5;
switch (obj->pin) { switch (obj->pin) {
case PA_0: case PA_0:
channel = 0; sConfig.Channel = ADC_CHANNEL_0;
break; break;
case PA_1: case PA_1:
channel = 1; sConfig.Channel = ADC_CHANNEL_1;
break; break;
case PA_2: case PA_2:
channel = 2; sConfig.Channel = ADC_CHANNEL_2;
break; break;
case PA_3: case PA_3:
channel = 3; sConfig.Channel = ADC_CHANNEL_3;
break; break;
case PA_4: case PA_4:
channel = 4; sConfig.Channel = ADC_CHANNEL_4;
break; break;
case PA_5: case PA_5:
channel = 5; sConfig.Channel = ADC_CHANNEL_5;
break; break;
case PA_6: case PA_6:
channel = 6; sConfig.Channel = ADC_CHANNEL_6;
break; break;
case PA_7: case PA_7:
channel = 7; sConfig.Channel = ADC_CHANNEL_7;
break; break;
case PB_0: case PB_0:
channel = 8; sConfig.Channel = ADC_CHANNEL_8;
break; break;
case PB_1: case PB_1:
channel = 9; sConfig.Channel = ADC_CHANNEL_9;
break; break;
case PC_0: case PC_0:
channel = 10; sConfig.Channel = ADC_CHANNEL_10;
break; break;
case PC_1: case PC_1:
channel = 11; sConfig.Channel = ADC_CHANNEL_11;
break; break;
case PC_2: case PC_2:
channel = 12; sConfig.Channel = ADC_CHANNEL_12;
break; break;
case PC_3: case PC_3:
channel = 13; sConfig.Channel = ADC_CHANNEL_13;
break; break;
case PC_4: case PC_4:
channel = 14; sConfig.Channel = ADC_CHANNEL_14;
break; break;
case PC_5: case PC_5:
channel = 15; sConfig.Channel = ADC_CHANNEL_15;
break; break;
default: default:
return 0; return 0;
} }
ADC_RegularChannelConfig(adc, channel, 1, ADC_SampleTime_7Cycles5); HAL_ADC_ConfigChannel(&AdcHandle, &sConfig);
ADC_SoftwareStartConvCmd(adc, ENABLE); // Start conversion HAL_ADC_Start(&AdcHandle); // Start conversion
while (ADC_GetFlagStatus(adc, ADC_FLAG_EOC) == RESET); // Wait end of conversion // Wait end of conversion and get value
if (HAL_ADC_PollForConversion(&AdcHandle, 10) == HAL_OK) {
return (ADC_GetConversionValue(adc)); // Get conversion value return (HAL_ADC_GetValue(&AdcHandle));
} else {
return 0;
}
} }
uint16_t analogin_read_u16(analogin_t *obj) uint16_t analogin_read_u16(analogin_t *obj)

10
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/gpio_api.c
View File

@ -38,15 +38,17 @@ uint32_t gpio_set(PinName pin)
{ {
MBED_ASSERT(pin != (PinName)NC); MBED_ASSERT(pin != (PinName)NC);
pin_function(pin, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
return (uint32_t)(1 << ((uint32_t)pin & 0xF)); // Return the pin mask return (uint32_t)(1 << ((uint32_t)pin & 0xF)); // Return the pin mask
} }
void gpio_init(gpio_t *obj, PinName pin) void gpio_init(gpio_t *obj, PinName pin)
{ {
obj->pin = pin; obj->pin = pin;
if (pin == (PinName)NC) if (pin == (PinName)NC) {
return; return;
}
uint32_t port_index = STM_PORT(pin); uint32_t port_index = STM_PORT(pin);
@ -70,8 +72,8 @@ void gpio_dir(gpio_t *obj, PinDirection direction)
{ {
MBED_ASSERT(obj->pin != (PinName)NC); MBED_ASSERT(obj->pin != (PinName)NC);
if (direction == PIN_OUTPUT) { if (direction == PIN_OUTPUT) {
pin_function(obj->pin, STM_PIN_DATA(GPIO_Mode_Out_PP, 0)); pin_function(obj->pin, STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0));
} else { // PIN_INPUT } else { // PIN_INPUT
pin_function(obj->pin, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
} }
} }

67
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/gpio_irq_api.c
View File

@ -38,7 +38,9 @@
#define EDGE_FALL (2) #define EDGE_FALL (2)
#define EDGE_BOTH (3) #define EDGE_BOTH (3)
// Number of EXTI irq vectors (EXTI0, EXTI1, EXTI2, EXTI3, EXTI4, EXTI5_9, EXTI10_15)
#define CHANNEL_NUM (7) #define CHANNEL_NUM (7)
// Max pins for one line (max with EXTI10_15) // Max pins for one line (max with EXTI10_15)
#define MAX_PIN_LINE (6) #define MAX_PIN_LINE (6)
@ -102,8 +104,8 @@ static void handle_interrupt_in(uint32_t irq_index, uint32_t max_num_pin_line)
uint32_t pin = (uint32_t)(1 << (gpio_channel->channel_pin[gpio_idx])); uint32_t pin = (uint32_t)(1 << (gpio_channel->channel_pin[gpio_idx]));
// Clear interrupt flag // Clear interrupt flag
if (EXTI_GetITStatus(pin) != RESET) { if (__HAL_GPIO_EXTI_GET_FLAG(pin) != RESET) {
EXTI_ClearITPendingBit(pin); __HAL_GPIO_EXTI_CLEAR_FLAG(pin);
if (gpio_channel->channel_ids[gpio_idx] == 0) continue; if (gpio_channel->channel_ids[gpio_idx] == 0) continue;
@ -229,28 +231,10 @@ int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32
// Enable GPIO clock // Enable GPIO clock
uint32_t gpio_add = Set_GPIO_Clock(port_index); uint32_t gpio_add = Set_GPIO_Clock(port_index);
// Enable AFIO clock // Configure GPIO
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); pin_function(pin, STM_PIN_DATA(STM_MODE_IT_FALLING, GPIO_NOPULL, 0));
// Connect EXTI line to pin
GPIO_EXTILineConfig(port_index, pin_index);
// Configure EXTI line
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line = (uint32_t)(1 << pin_index);
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
// Enable and set EXTI interrupt to the lowest priority
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = irq_n;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
// Enable EXTI interrupt
NVIC_SetVector(irq_n, vector); NVIC_SetVector(irq_n, vector);
NVIC_EnableIRQ(irq_n); NVIC_EnableIRQ(irq_n);
@ -284,69 +268,56 @@ void gpio_irq_free(gpio_irq_t *obj)
gpio_channel->channel_pin[gpio_idx] = 0; gpio_channel->channel_pin[gpio_idx] = 0;
// Disable EXTI line // Disable EXTI line
EXTI_InitTypeDef EXTI_InitStructure; pin_function(obj->pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
EXTI_StructInit(&EXTI_InitStructure);
EXTI_Init(&EXTI_InitStructure);
pin_function(obj->pin, STM_PIN_DATA(GPIO_Mode_Out_PP, 0));
pin_function(obj->pin, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0));
obj->event = EDGE_NONE; obj->event = EDGE_NONE;
} }
void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable) void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable)
{ {
EXTI_InitTypeDef EXTI_InitStructure; uint32_t mode = STM_MODE_IT_EVT_RESET;
uint32_t pin_index = STM_PIN(obj->pin); uint32_t pull = GPIO_NOPULL;
EXTI_InitStructure.EXTI_Line = (uint32_t)(1 << pin_index);
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_LineCmd = DISABLE; // Default
if (enable) { if (enable) {
if (event == IRQ_RISE) { if (event == IRQ_RISE) {
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
if ((obj->event == EDGE_FALL) || (obj->event == EDGE_BOTH)) { if ((obj->event == EDGE_FALL) || (obj->event == EDGE_BOTH)) {
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling; mode = STM_MODE_IT_RISING_FALLING;
obj->event = EDGE_BOTH; obj->event = EDGE_BOTH;
} else { // NONE or RISE } else { // NONE or RISE
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; mode = STM_MODE_IT_RISING;
obj->event = EDGE_RISE; obj->event = EDGE_RISE;
} }
} }
if (event == IRQ_FALL) { if (event == IRQ_FALL) {
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
if ((obj->event == EDGE_RISE) || (obj->event == EDGE_BOTH)) { if ((obj->event == EDGE_RISE) || (obj->event == EDGE_BOTH)) {
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling; mode = STM_MODE_IT_RISING_FALLING;
obj->event = EDGE_BOTH; obj->event = EDGE_BOTH;
} else { // NONE or FALL } else { // NONE or FALL
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; mode = STM_MODE_IT_FALLING;
obj->event = EDGE_FALL; obj->event = EDGE_FALL;
} }
} }
} else { // Disable } else { // Disable
if (event == IRQ_RISE) { if (event == IRQ_RISE) {
if ((obj->event == EDGE_FALL) || (obj->event == EDGE_BOTH)) { if ((obj->event == EDGE_FALL) || (obj->event == EDGE_BOTH)) {
EXTI_InitStructure.EXTI_LineCmd = ENABLE; mode = STM_MODE_IT_FALLING;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
obj->event = EDGE_FALL; obj->event = EDGE_FALL;
} else { // NONE or RISE } else { // NONE or RISE
EXTI_InitStructure.EXTI_LineCmd = DISABLE; mode = STM_MODE_IT_EVT_RESET;
obj->event = EDGE_NONE; obj->event = EDGE_NONE;
} }
} }
if (event == IRQ_FALL) { if (event == IRQ_FALL) {
if ((obj->event == EDGE_RISE) || (obj->event == EDGE_BOTH)) { if ((obj->event == EDGE_RISE) || (obj->event == EDGE_BOTH)) {
EXTI_InitStructure.EXTI_LineCmd = ENABLE; mode = STM_MODE_IT_RISING;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
obj->event = EDGE_RISE; obj->event = EDGE_RISE;
} else { // NONE or FALL } else { // NONE or FALL
EXTI_InitStructure.EXTI_LineCmd = DISABLE; mode = STM_MODE_IT_EVT_RESET;
obj->event = EDGE_NONE; obj->event = EDGE_NONE;
} }
} }
} }
EXTI_Init(&EXTI_InitStructure); pin_function(obj->pin, STM_PIN_DATA(mode, pull, 0));
} }
void gpio_irq_enable(gpio_irq_t *obj) void gpio_irq_enable(gpio_irq_t *obj)

5
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/gpio_object.h
View File

@ -64,11 +64,6 @@ static inline int gpio_read(gpio_t *obj)
return ((*obj->reg_in & obj->mask) ? 1 : 0); return ((*obj->reg_in & obj->mask) ? 1 : 0);
} }
static inline int gpio_is_connected(const gpio_t *obj) {
return obj->pin != (PinName)NC;
}
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

302
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/i2c_api.c
View File

@ -42,11 +42,13 @@
#define FLAG_TIMEOUT ((int)0x1000) #define FLAG_TIMEOUT ((int)0x1000)
#define LONG_TIMEOUT ((int)0x8000) #define LONG_TIMEOUT ((int)0x8000)
int i2c1_inited = 0; I2C_HandleTypeDef I2cHandle;
int i2c2_inited = 0;
void i2c_init(i2c_t *obj, PinName sda, PinName scl) void i2c_init(i2c_t *obj, PinName sda, PinName scl)
{ {
static int i2c1_inited = 0;
static int i2c2_inited = 0;
// Determine the I2C to use // Determine the I2C to use
I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA);
I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL);
@ -54,58 +56,61 @@ void i2c_init(i2c_t *obj, PinName sda, PinName scl)
obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl);
MBED_ASSERT(obj->i2c != (I2CName)NC); MBED_ASSERT(obj->i2c != (I2CName)NC);
// Enable I2C clock and configure I2C pins if not done before // Check if I2C peripherals are already configured
if ((obj->i2c == I2C_1) && !i2c1_inited) { if ((obj->i2c == I2C_1) && i2c1_inited) return;
if ((obj->i2c == I2C_2) && i2c2_inited) return;
// Set I2C clock
if (obj->i2c == I2C_1) {
i2c1_inited = 1; i2c1_inited = 1;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); __I2C1_CLK_ENABLE();
// Configure I2C pins
pinmap_pinout(scl, PinMap_I2C_SCL);
pin_mode(scl, OpenDrain);
pinmap_pinout(sda, PinMap_I2C_SDA);
pin_mode(sda, OpenDrain);
} }
if ((obj->i2c == I2C_2) && !i2c2_inited) {
if (obj->i2c == I2C_2) {
i2c2_inited = 1; i2c2_inited = 1;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); __I2C2_CLK_ENABLE();
// Configure I2C pins
pinmap_pinout(scl, PinMap_I2C_SCL);
pin_mode(scl, OpenDrain);
pinmap_pinout(sda, PinMap_I2C_SDA);
pin_mode(sda, OpenDrain);
} }
// Configure I2C pins
pinmap_pinout(sda, PinMap_I2C_SDA);
pinmap_pinout(scl, PinMap_I2C_SCL);
pin_mode(sda, OpenDrain);
pin_mode(scl, OpenDrain);
// Reset to clear pending flags if any // Reset to clear pending flags if any
i2c_reset(obj); i2c_reset(obj);
// I2C configuration // I2C configuration
i2c_frequency(obj, 100000); // 100 kHz per default i2c_frequency(obj, 100000); // 100 kHz per default
// I2C master by default
obj->slave = 0;
} }
void i2c_frequency(i2c_t *obj, int hz) void i2c_frequency(i2c_t *obj, int hz)
{ {
MBED_ASSERT((hz != 0) && (hz <= 400000));
I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
I2C_InitTypeDef I2C_InitStructure;
if ((hz != 0) && (hz <= 400000)) {
// wait before init // wait before init
timeout = LONG_TIMEOUT; timeout = LONG_TIMEOUT;
while ((I2C_GetFlagStatus(i2c, I2C_FLAG_BUSY)) && (timeout-- != 0)) { while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));
}
I2C_DeInit(i2c);
// I2C configuration // I2C configuration
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; I2cHandle.Init.ClockSpeed = hz;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; I2cHandle.Init.DutyCycle = I2C_DUTYCYCLE_2;
I2C_InitStructure.I2C_OwnAddress1 = 0; I2cHandle.Init.OwnAddress1 = 0;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; I2cHandle.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2cHandle.Init.DualAddressMode = I2C_DUALADDRESS_DISABLED;
I2C_InitStructure.I2C_ClockSpeed = hz; I2cHandle.Init.OwnAddress2 = 0;
I2C_Init(i2c, &I2C_InitStructure); I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLED;
I2cHandle.Init.NoStretchMode = I2C_NOSTRETCH_DISABLED;
HAL_I2C_Init(&I2cHandle);
I2C_Cmd(i2c, ENABLE); if (obj->slave) {
// Enable Address Acknowledge
I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
} }
} }
@ -114,16 +119,18 @@ inline int i2c_start(i2c_t *obj)
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
I2C_ClearFlag(i2c, I2C_FLAG_AF); // Clear Acknowledge failure flag I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
// Clear Acknowledge failure flag
__HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
// Generate the START condition // Generate the START condition
I2C_GenerateSTART(i2c, ENABLE); i2c->CR1 |= I2C_CR1_START;
// Wait the START condition has been correctly sent // Wait the START condition has been correctly sent
timeout = FLAG_TIMEOUT; timeout = FLAG_TIMEOUT;
while (I2C_GetFlagStatus(i2c, I2C_FLAG_SB) == RESET) { while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_SB) == RESET) {
timeout--; if ((timeout--) == 0) {
if (timeout == 0) {
return 1; return 1;
} }
} }
@ -135,7 +142,8 @@ inline int i2c_stop(i2c_t *obj)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
I2C_GenerateSTOP(i2c, ENABLE); // Generate the STOP condition
i2c->CR1 |= I2C_CR1_STOP;
return 0; return 0;
} }
@ -143,23 +151,26 @@ inline int i2c_stop(i2c_t *obj)
int i2c_read(i2c_t *obj, int address, char *data, int length, int stop) int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
int count; int count;
int value; int value;
// Generate start condition
i2c_start(obj); i2c_start(obj);
// Send slave address for read // Send address for read
I2C_Send7bitAddress(i2c, address, I2C_Direction_Receiver); i2c->DR = __HAL_I2C_7BIT_ADD_READ(address);
// Wait address is acknowledged // Wait address is acknowledged
timeout = FLAG_TIMEOUT; timeout = FLAG_TIMEOUT;
while (I2C_CheckEvent(i2c, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) == ERROR) { while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
timeout--; timeout--;
if (timeout == 0) { if (timeout == 0) {
return -1; return -1;
} }
} }
__HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
// Read all bytes except last one // Read all bytes except last one
for (count = 0; count < (length - 1); count++) { for (count = 0; count < (length - 1); count++) {
@ -183,27 +194,31 @@ int i2c_read(i2c_t *obj, int address, char *data, int length, int stop)
int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop) int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
int count; int count;
// Generate start condition
i2c_start(obj); i2c_start(obj);
// Send slave address for write // Send address for write
I2C_Send7bitAddress(i2c, address, I2C_Direction_Transmitter); i2c->DR = __HAL_I2C_7BIT_ADD_WRITE(address);
// Wait address is acknowledged // Wait address is acknowledged
timeout = FLAG_TIMEOUT; timeout = FLAG_TIMEOUT;
while (I2C_CheckEvent(i2c, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == ERROR) { while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == RESET) {
timeout--; timeout--;
if (timeout == 0) { if (timeout == 0) {
return -1; return -1;
} }
} }
__HAL_I2C_CLEAR_ADDRFLAG(&I2cHandle);
// Write all bytes
for (count = 0; count < length; count++) { for (count = 0; count < length; count++) {
if (i2c_byte_write(obj, data[count]) != 1) { if (i2c_byte_write(obj, data[count]) != 1) {
i2c_stop(obj); i2c_stop(obj);
return 0; return -1;
} }
} }
@ -218,29 +233,25 @@ int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
int i2c_byte_read(i2c_t *obj, int last) int i2c_byte_read(i2c_t *obj, int last)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
uint8_t data;
int timeout; int timeout;
if (last) { if (last) {
// Don't acknowledge the last byte // Don't acknowledge the last byte
I2C_AcknowledgeConfig(i2c, DISABLE); i2c->CR1 &= ~I2C_CR1_ACK;
} else { } else {
// Acknowledge the byte // Acknowledge the byte
I2C_AcknowledgeConfig(i2c, ENABLE); i2c->CR1 |= I2C_CR1_ACK;
} }
// Wait until the byte is received // Wait until the byte is received
timeout = FLAG_TIMEOUT; timeout = FLAG_TIMEOUT;
while (I2C_GetFlagStatus(i2c, I2C_FLAG_RXNE) == RESET) { while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
timeout--; if ((timeout--) == 0) {
if (timeout == 0) {
return -1; return -1;
} }
} }
data = I2C_ReceiveData(i2c); return (int)i2c->DR;
return (int)data;
} }
int i2c_byte_write(i2c_t *obj, int data) int i2c_byte_write(i2c_t *obj, int data)
@ -248,14 +259,13 @@ int i2c_byte_write(i2c_t *obj, int data)
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
I2C_SendData(i2c, (uint8_t)data); i2c->DR = (uint8_t)data;
// Wait until the byte is transmitted // Wait until the byte is transmitted
timeout = FLAG_TIMEOUT; timeout = FLAG_TIMEOUT;
while ((I2C_GetFlagStatus(i2c, I2C_FLAG_TXE) == RESET) && while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) &&
(I2C_GetFlagStatus(i2c, I2C_FLAG_BTF) == RESET)) { (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == RESET)) {
timeout--; if ((timeout--) == 0) {
if (timeout == 0) {
return 0; return 0;
} }
} }
@ -265,21 +275,20 @@ int i2c_byte_write(i2c_t *obj, int data)
void i2c_reset(i2c_t *obj) void i2c_reset(i2c_t *obj)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
int timeout; int timeout;
// wait before reset // Wait before reset
timeout = LONG_TIMEOUT; timeout = LONG_TIMEOUT;
while ((I2C_GetFlagStatus(i2c, I2C_FLAG_BUSY)) && (timeout-- != 0)) { while ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY)) && (timeout-- != 0));
}
if (obj->i2c == I2C_1) { if (obj->i2c == I2C_1) {
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE); __I2C1_FORCE_RESET();
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE); __I2C1_RELEASE_RESET();
} }
if (obj->i2c == I2C_2) { if (obj->i2c == I2C_2) {
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE); __I2C2_FORCE_RESET();
RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, DISABLE); __I2C2_RELEASE_RESET();
} }
} }
@ -288,7 +297,7 @@ void i2c_reset(i2c_t *obj)
void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask) void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
{ {
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c); I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
uint16_t tmpreg; uint16_t tmpreg = 0;
// Get the old register value // Get the old register value
tmpreg = i2c->OAR1; tmpreg = i2c->OAR1;
@ -302,7 +311,12 @@ void i2c_slave_address(i2c_t *obj, int idx, uint32_t address, uint32_t mask)
void i2c_slave_mode(i2c_t *obj, int enable_slave) void i2c_slave_mode(i2c_t *obj, int enable_slave)
{ {
// Nothing to do I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
if (enable_slave) {
obj->slave = 1;
/* Enable Address Acknowledge */
I2cHandle.Instance->CR1 |= I2C_CR1_ACK;
}
} }
// See I2CSlave.h // See I2CSlave.h
@ -313,70 +327,132 @@ void i2c_slave_mode(i2c_t *obj, int enable_slave)
int i2c_slave_receive(i2c_t *obj) int i2c_slave_receive(i2c_t *obj)
{ {
I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
int retValue = NoData; int retValue = NoData;
uint32_t event;
I2C_TypeDef *i2c = (I2C_TypeDef *)(obj->i2c);
event = I2C_GetLastEvent(i2c); if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == 1) {
if (event != 0) { if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_ADDR) == 1) {
switch (event) { if (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TRA) == 1) {
case I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED:
retValue = WriteAddressed;
break;
case I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED:
retValue = ReadAddressed; retValue = ReadAddressed;
break; } else {
case I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED: retValue = WriteAddressed;
retValue = WriteGeneral; }
break; __HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_ADDR);
default: }
retValue = NoData;
break;
} }
// clear ADDR
if ((retValue == WriteAddressed) || (retValue == ReadAddressed)) {
// read SR to clear ADDR flag
i2c->SR1;
i2c->SR2;
}
// clear stopf
if (I2C_GetFlagStatus(i2c, I2C_FLAG_STOPF) == SET) {
// read SR1 and write CR1 to clear STOP flag
i2c->SR1;
I2C_Cmd(i2c, ENABLE);
}
// clear AF
if (I2C_GetFlagStatus(i2c, I2C_FLAG_AF) == SET) {
I2C_ClearFlag(i2c, I2C_FLAG_AF);
}
}
return (retValue); return (retValue);
} }
int i2c_slave_read(i2c_t *obj, char *data, int length) int i2c_slave_read(i2c_t *obj, char *data, int length)
{ {
int count = 0; uint32_t Timeout;
int size = 0;
// Read all bytes I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
for (count = 0; count < length; count++) {
data[count] = i2c_byte_read(obj, 0); while (length > 0) {
// Wait until RXNE flag is set
// Wait until the byte is received
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_RXNE) == RESET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
} }
return count; // Read data
(*data++) = I2cHandle.Instance->DR;
length--;
size++;
if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
// Read data
(*data++) = I2cHandle.Instance->DR;
length--;
size++;
}
}
// Wait until STOP flag is set
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_STOPF) == RESET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
}
// Clear STOP flag
__HAL_I2C_CLEAR_STOPFLAG(&I2cHandle);
// Wait until BUSY flag is reset
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
}
return size;
} }
int i2c_slave_write(i2c_t *obj, const char *data, int length) int i2c_slave_write(i2c_t *obj, const char *data, int length)
{ {
int count = 0; uint32_t Timeout;
int size = 0;
// Write all bytes I2cHandle.Instance = (I2C_TypeDef *)(obj->i2c);
for (count = 0; count < length; count++) {
i2c_byte_write(obj, data[count]); while (length > 0) {
// Wait until TXE flag is set
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_TXE) == RESET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
} }
return count; // Write data
I2cHandle.Instance->DR = (*data++);
length--;
size++;
if ((__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BTF) == SET) && (length != 0)) {
// Write data to DR
I2cHandle.Instance->DR = (*data++);
length--;
size++;
} }
}
// Wait until AF flag is set
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_AF) == RESET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
}
// Clear AF flag
__HAL_I2C_CLEAR_FLAG(&I2cHandle, I2C_FLAG_AF);
// Wait until BUSY flag is reset
Timeout = FLAG_TIMEOUT;
while (__HAL_I2C_GET_FLAG(&I2cHandle, I2C_FLAG_BUSY) == SET) {
Timeout--;
if (Timeout == 0) {
return -1;
}
}
return size;
}
#endif // DEVICE_I2CSLAVE #endif // DEVICE_I2CSLAVE

2
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/mbed_overrides.c
View File

@ -32,4 +32,6 @@ void mbed_sdk_init()
{ {
// Update the SystemCoreClock variable. // Update the SystemCoreClock variable.
SystemCoreClockUpdate(); SystemCoreClockUpdate();
// Need to restart HAL driver after the RAM is initialized
HAL_Init();
} }

1
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/objects.h
View File

@ -86,6 +86,7 @@ struct spi_s {
struct i2c_s { struct i2c_s {
I2CName i2c; I2CName i2c;
uint32_t slave;
}; };
struct pwmout_s { struct pwmout_s {

113
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/pinmap.c
View File

@ -32,19 +32,22 @@
#include "PortNames.h" #include "PortNames.h"
#include "mbed_error.h" #include "mbed_error.h"
// Alternate-function mapping // GPIO mode look-up table
#define AF_NUM (10) // Warning: the elements order must be the same as the one defined in PinNames.h
static const uint32_t AF_mapping[AF_NUM] = { static const uint32_t gpio_mode[13] = {
0, // 0 = No AF GPIO_MODE_INPUT, // 0 = STM_MODE_INPUT
GPIO_Remap_SPI1, // 1 GPIO_MODE_OUTPUT_PP, // 1 = STM_MODE_OUTPUT_PP
GPIO_Remap_I2C1, // 2 GPIO_MODE_OUTPUT_OD, // 2 = STM_MODE_OUTPUT_OD
GPIO_Remap_USART1, // 3 GPIO_MODE_AF_PP, // 3 = STM_MODE_AF_PP
GPIO_Remap_USART2, // 4 GPIO_MODE_AF_OD, // 4 = STM_MODE_AF_OD
GPIO_PartialRemap_USART3, // 5 GPIO_MODE_ANALOG, // 5 = STM_MODE_ANALOG
GPIO_PartialRemap_TIM1, // 6 GPIO_MODE_IT_RISING, // 6 = STM_MODE_IT_RISING
GPIO_PartialRemap_TIM3, // 7 GPIO_MODE_IT_FALLING, // 7 = STM_MODE_IT_FALLING
GPIO_FullRemap_TIM2, // 8 GPIO_MODE_IT_RISING_FALLING, // 8 = STM_MODE_IT_RISING_FALLING
GPIO_FullRemap_TIM3 // 9 GPIO_MODE_EVT_RISING, // 9 = STM_MODE_EVT_RISING
GPIO_MODE_EVT_FALLING, // 10 = STM_MODE_EVT_FALLING
GPIO_MODE_EVT_RISING_FALLING, // 11 = STM_MODE_EVT_RISING_FALLING
0x10000000 // 12 = STM_MODE_IT_EVT_RESET (not in STM32Cube HAL)
}; };
// Enable GPIO clock and return GPIO base address // Enable GPIO clock and return GPIO base address
@ -54,22 +57,22 @@ uint32_t Set_GPIO_Clock(uint32_t port_idx)
switch (port_idx) { switch (port_idx) {
case PortA: case PortA:
gpio_add = GPIOA_BASE; gpio_add = GPIOA_BASE;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); __GPIOA_CLK_ENABLE();
break; break;
case PortB: case PortB:
gpio_add = GPIOB_BASE; gpio_add = GPIOB_BASE;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); __GPIOB_CLK_ENABLE();
break; break;
case PortC: case PortC:
gpio_add = GPIOC_BASE; gpio_add = GPIOC_BASE;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); __GPIOC_CLK_ENABLE();
break; break;
case PortD: case PortD:
gpio_add = GPIOD_BASE; gpio_add = GPIOD_BASE;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE); __GPIOD_CLK_ENABLE();
break; break;
default: default:
error("Port number is not correct."); error("Pinmap error: wrong port number.");
break; break;
} }
return gpio_add; return gpio_add;
@ -83,6 +86,7 @@ void pin_function(PinName pin, int data)
MBED_ASSERT(pin != (PinName)NC); MBED_ASSERT(pin != (PinName)NC);
// Get the pin informations // Get the pin informations
uint32_t mode = STM_PIN_MODE(data); uint32_t mode = STM_PIN_MODE(data);
uint32_t pupd = STM_PIN_PUPD(data);
uint32_t afnum = STM_PIN_AFNUM(data); uint32_t afnum = STM_PIN_AFNUM(data);
uint32_t port_index = STM_PORT(pin); uint32_t port_index = STM_PORT(pin);
@ -93,28 +97,59 @@ void pin_function(PinName pin, int data)
GPIO_TypeDef *gpio = (GPIO_TypeDef *)gpio_add; GPIO_TypeDef *gpio = (GPIO_TypeDef *)gpio_add;
// Enable AFIO clock // Enable AFIO clock
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); __HAL_RCC_AFIO_CLK_ENABLE();
// Configure Alternate Function // Configure Alternate Function
// Warning: Must be done before the GPIO is initialized // Warning: Must be done before the GPIO is initialized
if ((afnum > 0) && (afnum < AF_NUM)) { if (afnum > 0) {
GPIO_PinRemapConfig(AF_mapping[afnum], ENABLE); switch (afnum) {
case 1: // Remap SPI1
__HAL_AFIO_REMAP_SPI1_ENABLE();
break;
case 2: // Remap I2C1
__HAL_AFIO_REMAP_I2C1_ENABLE();
break;
case 3: // Remap USART1
__HAL_AFIO_REMAP_USART1_ENABLE();
break;
case 4: // Remap USART2
__HAL_AFIO_REMAP_USART2_ENABLE();
break;
case 5: // Partial Remap USART3
__HAL_AFIO_REMAP_USART3_PARTIAL();
break;
case 6: // Partial Remap TIM1
__HAL_AFIO_REMAP_TIM1_PARTIAL();
break;
case 7: // Partial Remap TIM3
__HAL_AFIO_REMAP_TIM3_PARTIAL();
break;
case 8: // Full Remap TIM2
__HAL_AFIO_REMAP_TIM2_ENABLE();
break;
case 9: // Full Remap TIM3
__HAL_AFIO_REMAP_TIM3_ENABLE();
break;
default:
break;
}
} }
// Configure GPIO // Configure GPIO
GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = (uint16_t)(1 << pin_index); GPIO_InitStructure.Pin = (uint32_t)(1 << pin_index);
GPIO_InitStructure.GPIO_Mode = (GPIOMode_TypeDef)mode; GPIO_InitStructure.Mode = gpio_mode[mode];
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.Pull = pupd;
GPIO_Init(gpio, &GPIO_InitStructure); GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(gpio, &GPIO_InitStructure);
// Disconnect JTAG-DP + SW-DP signals. // Disconnect JTAG-DP + SW-DP signals.
// Warning: Need to reconnect under reset // Warning: Need to reconnect under reset
if ((pin == PA_13) || (pin == PA_14)) { if ((pin == PA_13) || (pin == PA_14)) {
GPIO_PinRemapConfig(GPIO_Remap_SWJ_Disable, ENABLE); __HAL_AFIO_REMAP_SWJ_DISABLE(); // JTAG-DP Disabled and SW-DP Disabled
} }
if ((pin == PA_15) || (pin == PB_3) || (pin == PB_4)) { if ((pin == PA_15) || (pin == PB_3) || (pin == PB_4)) {
GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); __HAL_AFIO_REMAP_SWJ_NOJTAG(); // JTAG-DP Disabled and SW-DP enabled
} }
} }
@ -124,7 +159,6 @@ void pin_function(PinName pin, int data)
void pin_mode(PinName pin, PinMode mode) void pin_mode(PinName pin, PinMode mode)
{ {
MBED_ASSERT(pin != (PinName)NC); MBED_ASSERT(pin != (PinName)NC);
GPIO_InitTypeDef GPIO_InitStructure;
uint32_t port_index = STM_PORT(pin); uint32_t port_index = STM_PORT(pin);
uint32_t pin_index = STM_PIN(pin); uint32_t pin_index = STM_PIN(pin);
@ -136,14 +170,22 @@ void pin_mode(PinName pin, PinMode mode)
// Configure open-drain and pull-up/down // Configure open-drain and pull-up/down
switch (mode) { switch (mode) {
case PullNone: case PullNone:
return;
case PullUp:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
break; break;
case PullUp:
case PullDown: case PullDown:
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; // Set pull-up / pull-down for Input mode
if (pin_index < 8) {
if ((gpio->CRL & (0x03 << (pin_index * 4))) == 0) { // MODE bits = Input mode
gpio->CRL |= (0x08 << (pin_index * 4)); // Set pull-up / pull-down
}
} else {
if ((gpio->CRH & (0x03 << ((pin_index % 8) * 4))) == 0) { // MODE bits = Input mode
gpio->CRH |= (0x08 << ((pin_index % 8) * 4)); // Set pull-up / pull-down
}
}
break; break;
case OpenDrain: case OpenDrain:
// Set open-drain for Output mode (General Purpose or Alternate Function)
if (pin_index < 8) { if (pin_index < 8) {
if ((gpio->CRL & (0x03 << (pin_index * 4))) > 0) { // MODE bits = Output mode if ((gpio->CRL & (0x03 << (pin_index * 4))) > 0) { // MODE bits = Output mode
gpio->CRL |= (0x04 << (pin_index * 4)); // Set open-drain gpio->CRL |= (0x04 << (pin_index * 4)); // Set open-drain
@ -153,13 +195,8 @@ void pin_mode(PinName pin, PinMode mode)
gpio->CRH |= (0x04 << ((pin_index % 8) * 4)); // Set open-drain gpio->CRH |= (0x04 << ((pin_index % 8) * 4)); // Set open-drain
} }
} }
return; break;
default: default:
break; break;
} }
// Configure GPIO
GPIO_InitStructure.GPIO_Pin = (uint16_t)(1 << pin_index);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(gpio, &GPIO_InitStructure);
} }

9
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/port_api.c
View File

@ -28,13 +28,12 @@
******************************************************************************* *******************************************************************************
*/ */
#include "port_api.h" #include "port_api.h"
#if DEVICE_PORTIN || DEVICE_PORTOUT
#include "pinmap.h" #include "pinmap.h"
#include "gpio_api.h" #include "gpio_api.h"
#include "mbed_error.h" #include "mbed_error.h"
#if DEVICE_PORTIN || DEVICE_PORTOUT
extern uint32_t Set_GPIO_Clock(uint32_t port_idx); extern uint32_t Set_GPIO_Clock(uint32_t port_idx);
// high nibble = port number (0=A, 1=B, 2=C, 3=D, 4=E, 5=F, ...) // high nibble = port number (0=A, 1=B, 2=C, 3=D, 4=E, 5=F, ...)
@ -69,9 +68,9 @@ void port_dir(port_t *obj, PinDirection dir)
for (i = 0; i < 16; i++) { // Process all pins for (i = 0; i < 16; i++) { // Process all pins
if (obj->mask & (1 << i)) { // If the pin is used if (obj->mask & (1 << i)) { // If the pin is used
if (dir == PIN_OUTPUT) { if (dir == PIN_OUTPUT) {
pin_function(port_pin(obj->port, i), STM_PIN_DATA(GPIO_Mode_Out_PP, 0)); pin_function(port_pin(obj->port, i), STM_PIN_DATA(STM_MODE_OUTPUT_PP, GPIO_NOPULL, 0));
} else { // PIN_INPUT } else { // PIN_INPUT
pin_function(port_pin(obj->port, i), STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(port_pin(obj->port, i), STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
} }
} }
} }

125
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/pwmout_api.c
View File

@ -27,26 +27,30 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************* *******************************************************************************
*/ */
#include "mbed_assert.h"
#include "pwmout_api.h" #include "pwmout_api.h"
#if DEVICE_PWMOUT #if DEVICE_PWMOUT
#include "cmsis.h" #include "cmsis.h"
#include "pinmap.h" #include "pinmap.h"
#include "mbed_error.h"
#include "PeripheralPins.h" #include "PeripheralPins.h"
static TIM_HandleTypeDef TimHandle;
void pwmout_init(pwmout_t* obj, PinName pin) void pwmout_init(pwmout_t* obj, PinName pin)
{ {
// Get the peripheral name from the pin and assign it to the object // Get the peripheral name from the pin and assign it to the object
obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM);
MBED_ASSERT(obj->pwm != (PWMName)NC);
if (obj->pwm == (PWMName)NC) {
error("PWM error: pinout mapping failed.");
}
// Enable TIM clock // Enable TIM clock
if (obj->pwm == PWM_1) RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE); if (obj->pwm == PWM_1) __TIM1_CLK_ENABLE();
if (obj->pwm == PWM_2) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); if (obj->pwm == PWM_2) __TIM2_CLK_ENABLE();
if (obj->pwm == PWM_3) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); if (obj->pwm == PWM_3) __TIM3_CLK_ENABLE();
if (obj->pwm == PWM_4) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
// Configure GPIO // Configure GPIO
pinmap_pinout(pin, PinMap_PWM); pinmap_pinout(pin, PinMap_PWM);
@ -61,102 +65,102 @@ void pwmout_init(pwmout_t* obj, PinName pin)
void pwmout_free(pwmout_t* obj) void pwmout_free(pwmout_t* obj)
{ {
// Configure GPIO // Configure GPIO
pin_function(obj->pin, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
} }
void pwmout_write(pwmout_t* obj, float value) void pwmout_write(pwmout_t* obj, float value)
{ {
TIM_TypeDef *tim = (TIM_TypeDef *)(obj->pwm); TIM_OC_InitTypeDef sConfig;
TIM_OCInitTypeDef TIM_OCInitStructure; int channel = 0;
int complementary_channel = 0;
if (value < 0.0) { TimHandle.Instance = (TIM_TypeDef *)(obj->pwm);
if (value < (float)0.0) {
value = 0.0; value = 0.0;
} else if (value > 1.0) { } else if (value > (float)1.0) {
value = 1.0; value = 1.0;
} }
obj->pulse = (uint32_t)((float)obj->period * value); obj->pulse = (uint32_t)((float)obj->period * value);
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_Pulse = obj->pulse;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
// Configure channels // Configure channels
sConfig.OCMode = TIM_OCMODE_PWM1;
sConfig.Pulse = obj->pulse;
sConfig.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfig.OCFastMode = TIM_OCFAST_DISABLE;
sConfig.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
switch (obj->pin) { switch (obj->pin) {
// Channels 1 // Channels 1
case PA_6: case PA_6:
case PA_8: case PA_8:
case PA_15: case PA_15:
case PB_4: case PB_4:
//case PB_6:
case PC_6: case PC_6:
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; channel = TIM_CHANNEL_1;
TIM_OC1PreloadConfig(tim, TIM_OCPreload_Enable);
TIM_OC1Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 1N // Channels 1N
//case PA_7:
case PB_13: case PB_13:
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable; channel = TIM_CHANNEL_1;
TIM_OC1PreloadConfig(tim, TIM_OCPreload_Enable); complementary_channel = 1;
TIM_OC1Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 2 // Channels 2
case PA_1: case PA_1:
case PA_7: case PA_7:
case PA_9: case PA_9:
case PB_3: case PB_3:
case PB_5: case PB_5:
//case PB_7:
case PC_7: case PC_7:
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; channel = TIM_CHANNEL_2;
TIM_OC2PreloadConfig(tim, TIM_OCPreload_Enable);
TIM_OC2Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 2N // Channels 2N
//case PB_0:
case PB_14: case PB_14:
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable; channel = TIM_CHANNEL_2;
TIM_OC2PreloadConfig(tim, TIM_OCPreload_Enable); complementary_channel = 1;
TIM_OC2Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 3 // Channels 3
case PA_2: case PA_2:
case PA_10: case PA_10:
case PB_0: case PB_0:
//case PB_8:
case PB_10: case PB_10:
case PC_8: case PC_8:
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; channel = TIM_CHANNEL_3;
TIM_OC3PreloadConfig(tim, TIM_OCPreload_Enable);
TIM_OC3Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 3N // Channels 3N
//case PB_1:
case PB_15: case PB_15:
TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable; channel = TIM_CHANNEL_3;
TIM_OC3PreloadConfig(tim, TIM_OCPreload_Enable); complementary_channel = 1;
TIM_OC3Init(tim, &TIM_OCInitStructure);
break; break;
// Channels 4 // Channels 4
case PA_3: case PA_3:
case PA_11: case PA_11:
case PB_1: case PB_1:
//case PB_9:
case PB_11: case PB_11:
case PC_9: case PC_9:
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable; channel = TIM_CHANNEL_4;
TIM_OC4PreloadConfig(tim, TIM_OCPreload_Enable);
TIM_OC4Init(tim, &TIM_OCInitStructure);
break; break;
default: default:
return; return;
} }
TIM_CtrlPWMOutputs(tim, ENABLE); HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, channel);
if (complementary_channel) {
HAL_TIMEx_PWMN_Start(&TimHandle, channel);
} else {
HAL_TIM_PWM_Start(&TimHandle, channel);
}
} }
float pwmout_read(pwmout_t* obj) float pwmout_read(pwmout_t* obj)
@ -165,7 +169,7 @@ float pwmout_read(pwmout_t* obj)
if (obj->period > 0) { if (obj->period > 0) {
value = (float)(obj->pulse) / (float)(obj->period); value = (float)(obj->pulse) / (float)(obj->period);
} }
return ((value > 1.0) ? (1.0) : (value)); return ((value > (float)1.0) ? (float)(1.0) : (value));
} }
void pwmout_period(pwmout_t* obj, float seconds) void pwmout_period(pwmout_t* obj, float seconds)
@ -180,25 +184,28 @@ void pwmout_period_ms(pwmout_t* obj, int ms)
void pwmout_period_us(pwmout_t* obj, int us) void pwmout_period_us(pwmout_t* obj, int us)
{ {
TIM_TypeDef *tim = (TIM_TypeDef *)(obj->pwm); TimHandle.Instance = (TIM_TypeDef *)(obj->pwm);
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
float dc = pwmout_read(obj); float dc = pwmout_read(obj);
TIM_Cmd(tim, DISABLE); __HAL_TIM_DISABLE(&TimHandle);
obj->period = us; // Update the SystemCoreClock variable
SystemCoreClockUpdate();
TIM_TimeBaseStructure.TIM_Period = obj->period - 1; TimHandle.Init.Period = us - 1;
TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 µs tick TimHandle.Init.Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 us tick
TIM_TimeBaseStructure.TIM_ClockDivision = 0; TimHandle.Init.ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
TIM_TimeBaseInit(tim, &TIM_TimeBaseStructure); HAL_TIM_PWM_Init(&TimHandle);
// Set duty cycle again // Set duty cycle again
pwmout_write(obj, dc); pwmout_write(obj, dc);
TIM_ARRPreloadConfig(tim, ENABLE); // Save for future use
TIM_Cmd(tim, ENABLE); obj->period = us;
__HAL_TIM_ENABLE(&TimHandle);
} }
void pwmout_pulsewidth(pwmout_t* obj, float seconds) void pwmout_pulsewidth(pwmout_t* obj, float seconds)

165
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/rtc_api.c
View File

@ -31,69 +31,83 @@
#if DEVICE_RTC #if DEVICE_RTC
#include "wait_api.h" #include "mbed_error.h"
#define LSE_STARTUP_TIMEOUT ((uint16_t)700) // delay in ms
static int rtc_inited = 0; static int rtc_inited = 0;
static RTC_HandleTypeDef RtcHandle;
void rtc_init(void) void rtc_init(void)
{ {
uint32_t StartUpCounter = 0; RCC_OscInitTypeDef RCC_OscInitStruct;
uint32_t LSEStatus = 0;
uint32_t rtc_freq = 0;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE); // Enable PWR and Backup clock if (rtc_inited) return;
rtc_inited = 1;
PWR_BackupAccessCmd(ENABLE); // Allow access to Backup Domain RtcHandle.Instance = RTC;
BKP_DeInit(); // Reset Backup Domain // Enable Power clock
__HAL_RCC_PWR_CLK_ENABLE();
// Enable LSE clock // Enable access to Backup domain
RCC_LSEConfig(RCC_LSE_ON); HAL_PWR_EnableBkUpAccess();
// Wait till LSE is ready // Reset Backup domain
do { __HAL_RCC_BACKUPRESET_FORCE();
LSEStatus = RCC_GetFlagStatus(RCC_FLAG_LSERDY); __HAL_RCC_BACKUPRESET_RELEASE();
wait_ms(1);
StartUpCounter++;
} while ((LSEStatus == 0) && (StartUpCounter <= LSE_STARTUP_TIMEOUT));
if (StartUpCounter > LSE_STARTUP_TIMEOUT) { // Enable LSE Oscillator
// The LSE has not started, use LSI instead. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
// The RTC Clock may vary due to LSI frequency dispersion. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!
RCC_LSEConfig(RCC_LSE_OFF); RCC_OscInitStruct.LSEState = RCC_LSE_ON; // External 32.768 kHz clock on OSC_IN/OSC_OUT
RCC_LSICmd(ENABLE); // Enable LSI if (HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK) {
while (RCC_GetFlagStatus(RCC_FLAG_LSIRDY) == RESET) {} // Wait until ready // Connect LSE to RTC
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSI); // Select the RTC Clock Source __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);
rtc_freq = 40000; // [TODO] To be measured precisely using a timer input capture
} else { } else {
// The LSE has correctly started // Enable LSI clock
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE); // Select the RTC Clock Source RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;
rtc_freq = LSE_VALUE; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; // Mandatory, otherwise the PLL is reconfigured!
RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
RCC_OscInitStruct.LSIState = RCC_LSI_ON;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
error("RTC error: LSI clock initialization failed.");
}
// Connect LSI to RTC
__HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSI);
} }
RCC_RTCCLKCmd(ENABLE); // Enable RTC Clock // Enable RTC
__HAL_RCC_RTC_ENABLE();
RTC_WaitForSynchro(); // Wait for RTC registers synchronization RtcHandle.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
RTC_WaitForLastTask(); // Wait until last write operation on RTC registers has finished if (HAL_RTC_Init(&RtcHandle) != HAL_OK) {
error("RTC error: RTC initialization failed.");
// Set RTC period to 1 sec }
RTC_SetPrescaler(rtc_freq - 1);
RTC_WaitForLastTask(); // Wait until last write operation on RTC registers has finished
rtc_inited = 1;
} }
void rtc_free(void) void rtc_free(void)
{ {
// Disable RTC, LSE and LSI clocks // Enable Power clock
PWR_BackupAccessCmd(ENABLE); // Allow access to Backup Domain __PWR_CLK_ENABLE();
RCC_RTCCLKCmd(DISABLE);
RCC_LSEConfig(RCC_LSE_OFF); // Enable access to Backup domain
RCC_LSICmd(DISABLE); HAL_PWR_EnableBkUpAccess();
// Reset Backup domain
__HAL_RCC_BACKUPRESET_FORCE();
__HAL_RCC_BACKUPRESET_RELEASE();
// Disable access to Backup domain
HAL_PWR_DisableBkUpAccess();
// Disable LSI and LSE clocks
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
HAL_RCC_OscConfig(&RCC_OscInitStruct);
rtc_inited = 0; rtc_inited = 0;
} }
@ -103,16 +117,73 @@ int rtc_isenabled(void)
return rtc_inited; return rtc_inited;
} }
/*
RTC Registers
RTC_WeekDay 1=monday, 2=tuesday, ..., 7=sunday
RTC_Month 1=january, 2=february, ..., 12=december
RTC_Date day of the month 1-31
RTC_Year year 0-99
struct tm
tm_sec seconds after the minute 0-61
tm_min minutes after the hour 0-59
tm_hour hours since midnight 0-23
tm_mday day of the month 1-31
tm_mon months since January 0-11
tm_year years since 1900
tm_wday days since Sunday 0-6
tm_yday days since January 1 0-365
tm_isdst Daylight Saving Time flag
*/
time_t rtc_read(void) time_t rtc_read(void)
{ {
return (time_t)RTC_GetCounter(); RTC_DateTypeDef dateStruct;
RTC_TimeTypeDef timeStruct;
struct tm timeinfo;
RtcHandle.Instance = RTC;
// Read actual date and time
// Warning: the time must be read first!
HAL_RTC_GetTime(&RtcHandle, &timeStruct, FORMAT_BIN);
HAL_RTC_GetDate(&RtcHandle, &dateStruct, FORMAT_BIN);
// Setup a tm structure based on the RTC
timeinfo.tm_wday = dateStruct.WeekDay;
timeinfo.tm_mon = dateStruct.Month - 1;
timeinfo.tm_mday = dateStruct.Date;
timeinfo.tm_year = dateStruct.Year + 100;
timeinfo.tm_hour = timeStruct.Hours;
timeinfo.tm_min = timeStruct.Minutes;
timeinfo.tm_sec = timeStruct.Seconds;
// Convert to timestamp
time_t t = mktime(&timeinfo);
return t;
} }
void rtc_write(time_t t) void rtc_write(time_t t)
{ {
RTC_WaitForLastTask(); // Wait until last write operation on RTC registers has finished RTC_DateTypeDef dateStruct;
RTC_SetCounter(t); // Change the current time RTC_TimeTypeDef timeStruct;
RTC_WaitForLastTask(); // Wait until last write operation on RTC registers has finished
RtcHandle.Instance = RTC;
// Convert the time into a tm
struct tm *timeinfo = localtime(&t);
// Fill RTC structures
dateStruct.WeekDay = timeinfo->tm_wday;
dateStruct.Month = timeinfo->tm_mon + 1;
dateStruct.Date = timeinfo->tm_mday;
dateStruct.Year = timeinfo->tm_year - 100;
timeStruct.Hours = timeinfo->tm_hour;
timeStruct.Minutes = timeinfo->tm_min;
timeStruct.Seconds = timeinfo->tm_sec;
// Change the RTC current date/time
HAL_RTC_SetDate(&RtcHandle, &dateStruct, FORMAT_BIN);
HAL_RTC_SetTime(&RtcHandle, &timeStruct, FORMAT_BIN);
} }
#endif #endif

162
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/serial_api.c
View File

@ -43,33 +43,30 @@ static uint32_t serial_irq_ids[UART_NUM] = {0, 0, 0};
static uart_irq_handler irq_handler; static uart_irq_handler irq_handler;
UART_HandleTypeDef UartHandle;
int stdio_uart_inited = 0; int stdio_uart_inited = 0;
serial_t stdio_uart; serial_t stdio_uart;
static void init_usart(serial_t *obj) static void init_uart(serial_t *obj)
{ {
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); UartHandle.Instance = (USART_TypeDef *)(obj->uart);
USART_InitTypeDef USART_InitStructure;
USART_Cmd(usart, DISABLE); UartHandle.Init.BaudRate = obj->baudrate;
UartHandle.Init.WordLength = obj->databits;
USART_InitStructure.USART_BaudRate = obj->baudrate; UartHandle.Init.StopBits = obj->stopbits;
USART_InitStructure.USART_WordLength = obj->databits; UartHandle.Init.Parity = obj->parity;
USART_InitStructure.USART_StopBits = obj->stopbits; UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
USART_InitStructure.USART_Parity = obj->parity;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
if (obj->pin_rx == NC) { if (obj->pin_rx == NC) {
USART_InitStructure.USART_Mode = USART_Mode_Tx; UartHandle.Init.Mode = UART_MODE_TX;
} else if (obj->pin_tx == NC) { } else if (obj->pin_tx == NC) {
USART_InitStructure.USART_Mode = USART_Mode_Rx; UartHandle.Init.Mode = UART_MODE_RX;
} else { } else {
USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx; UartHandle.Init.Mode = UART_MODE_TX_RX;
} }
USART_Init(usart, &USART_InitStructure); HAL_UART_Init(&UartHandle);
USART_Cmd(usart, ENABLE);
} }
void serial_init(serial_t *obj, PinName tx, PinName rx) void serial_init(serial_t *obj, PinName tx, PinName rx)
@ -82,34 +79,40 @@ void serial_init(serial_t *obj, PinName tx, PinName rx)
obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx);
MBED_ASSERT(obj->uart != (UARTName)NC); MBED_ASSERT(obj->uart != (UARTName)NC);
// Enable USART clock // Enable UART clock
if (obj->uart == UART_1) { if (obj->uart == UART_1) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); __HAL_RCC_USART1_CLK_ENABLE();
obj->index = 0; obj->index = 0;
} }
if (obj->uart == UART_2) { if (obj->uart == UART_2) {
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); __HAL_RCC_USART2_CLK_ENABLE();
obj->index = 1; obj->index = 1;
} }
if (obj->uart == UART_3) { if (obj->uart == UART_3) {
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); __HAL_RCC_USART3_CLK_ENABLE();
obj->index = 2; obj->index = 2;
} }
// Configure the UART pins // Configure UART pins
pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(tx, PinMap_UART_TX);
pinmap_pinout(rx, PinMap_UART_RX); pinmap_pinout(rx, PinMap_UART_RX);
if (tx != NC) {
pin_mode(tx, PullUp);
}
if (rx != NC) {
pin_mode(rx, PullUp);
}
// Configure UART // Configure UART
obj->baudrate = 9600; obj->baudrate = 9600;
obj->databits = USART_WordLength_8b; obj->databits = UART_WORDLENGTH_8B;
obj->stopbits = USART_StopBits_1; obj->stopbits = UART_STOPBITS_1;
obj->parity = USART_Parity_No; obj->parity = UART_PARITY_NONE;
obj->pin_tx = tx; obj->pin_tx = tx;
obj->pin_rx = rx; obj->pin_rx = rx;
init_usart(obj); init_uart(obj);
// For stdio management // For stdio management
if (obj->uart == STDIO_UART) { if (obj->uart == STDIO_UART) {
@ -122,24 +125,24 @@ void serial_free(serial_t *obj)
{ {
// Reset UART and disable clock // Reset UART and disable clock
if (obj->uart == UART_1) { if (obj->uart == UART_1) {
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE); __USART1_FORCE_RESET();
RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE); __USART1_RELEASE_RESET();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, DISABLE); __USART1_CLK_DISABLE();
} }
if (obj->uart == UART_2) { if (obj->uart == UART_2) {
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE); __USART2_FORCE_RESET();
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE); __USART2_RELEASE_RESET();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, DISABLE); __USART2_CLK_DISABLE();
} }
if (obj->uart == UART_3) { if (obj->uart == UART_3) {
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE); __USART3_FORCE_RESET();
RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE); __USART3_RELEASE_RESET();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, DISABLE); __USART3_CLK_DISABLE();
} }
// Configure GPIOs // Configure GPIOs
pin_function(obj->pin_tx, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_tx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(obj->pin_rx, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_rx, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
serial_irq_ids[obj->index] = 0; serial_irq_ids[obj->index] = 0;
} }
@ -147,70 +150,72 @@ void serial_free(serial_t *obj)
void serial_baud(serial_t *obj, int baudrate) void serial_baud(serial_t *obj, int baudrate)
{ {
obj->baudrate = baudrate; obj->baudrate = baudrate;
init_usart(obj); init_uart(obj);
} }
void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits) void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits)
{ {
if (data_bits == 9) { if (data_bits == 9) {
obj->databits = USART_WordLength_9b; obj->databits = UART_WORDLENGTH_9B;
} else { } else {
obj->databits = USART_WordLength_8b; obj->databits = UART_WORDLENGTH_8B;
} }
switch (parity) { switch (parity) {
case ParityOdd: case ParityOdd:
case ParityForced0: case ParityForced0:
obj->parity = USART_Parity_Odd; obj->parity = UART_PARITY_ODD;
break; break;
case ParityEven: case ParityEven:
case ParityForced1: case ParityForced1:
obj->parity = USART_Parity_Even; obj->parity = UART_PARITY_EVEN;
break; break;
default: // ParityNone default: // ParityNone
obj->parity = USART_Parity_No; obj->parity = UART_PARITY_NONE;
break; break;
} }
if (stop_bits == 2) { if (stop_bits == 2) {
obj->stopbits = USART_StopBits_2; obj->stopbits = UART_STOPBITS_2;
} else { } else {
obj->stopbits = USART_StopBits_1; obj->stopbits = UART_STOPBITS_1;
} }
init_usart(obj); init_uart(obj);
} }
/****************************************************************************** /******************************************************************************
* INTERRUPTS HANDLING * INTERRUPTS HANDLING
******************************************************************************/ ******************************************************************************/
// not api static void uart_irq(UARTName name, int id)
static void uart_irq(USART_TypeDef* usart, int id)
{ {
UartHandle.Instance = (USART_TypeDef *)name;
if (serial_irq_ids[id] != 0) { if (serial_irq_ids[id] != 0) {
if (USART_GetITStatus(usart, USART_IT_TC) != RESET) { if (__HAL_UART_GET_FLAG(&UartHandle, UART_FLAG_TC) != RESET) {
irq_handler(serial_irq_ids[id], TxIrq); irq_handler(serial_irq_ids[id], TxIrq);
USART_ClearITPendingBit(usart, USART_IT_TC); __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_TC);
} }
if (USART_GetITStatus(usart, USART_IT_RXNE) != RESET) { if (__HAL_UART_GET_FLAG(&UartHandle, UART_FLAG_RXNE) != RESET) {
irq_handler(serial_irq_ids[id], RxIrq); irq_handler(serial_irq_ids[id], RxIrq);
USART_ClearITPendingBit(usart, USART_IT_RXNE); __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_RXNE);
} }
} }
} }
static void uart1_irq(void) static void uart1_irq(void)
{ {
uart_irq((USART_TypeDef*)UART_1, 0); uart_irq(UART_1, 0);
} }
static void uart2_irq(void) static void uart2_irq(void)
{ {
uart_irq((USART_TypeDef*)UART_2, 1); uart_irq(UART_2, 1);
} }
static void uart3_irq(void) static void uart3_irq(void)
{ {
uart_irq((USART_TypeDef*)UART_3, 2); uart_irq(UART_3, 2);
} }
void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id) void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
@ -223,7 +228,8 @@ void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
{ {
IRQn_Type irq_n = (IRQn_Type)0; IRQn_Type irq_n = (IRQn_Type)0;
uint32_t vector = 0; uint32_t vector = 0;
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart);
UartHandle.Instance = (USART_TypeDef *)(obj->uart);
if (obj->uart == UART_1) { if (obj->uart == UART_1) {
irq_n = USART1_IRQn; irq_n = USART1_IRQn;
@ -243,9 +249,9 @@ void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
if (enable) { if (enable) {
if (irq == RxIrq) { if (irq == RxIrq) {
USART_ITConfig(usart, USART_IT_RXNE, ENABLE); __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_RXNE);
} else { // TxIrq } else { // TxIrq
USART_ITConfig(usart, USART_IT_TC, ENABLE); __HAL_UART_ENABLE_IT(&UartHandle, UART_IT_TC);
} }
NVIC_SetVector(irq_n, vector); NVIC_SetVector(irq_n, vector);
@ -256,13 +262,13 @@ void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
int all_disabled = 0; int all_disabled = 0;
if (irq == RxIrq) { if (irq == RxIrq) {
USART_ITConfig(usart, USART_IT_RXNE, DISABLE); __HAL_UART_DISABLE_IT(&UartHandle, UART_IT_RXNE);
// Check if TxIrq is disabled too // Check if TxIrq is disabled too
if ((usart->CR1 & USART_CR1_TXEIE) == 0) all_disabled = 1; if ((UartHandle.Instance->CR1 & USART_CR1_TCIE) == 0) all_disabled = 1;
} else { // TxIrq } else { // TxIrq
USART_ITConfig(usart, USART_IT_TXE, DISABLE); __HAL_UART_DISABLE_IT(&UartHandle, UART_IT_TC);
// Check if RxIrq is disabled too // Check if RxIrq is disabled too
if ((usart->CR1 & USART_CR1_RXNEIE) == 0) all_disabled = 1; if ((UartHandle.Instance->CR1 & USART_CR1_RXNEIE) == 0) all_disabled = 1;
} }
if (all_disabled) NVIC_DisableIRQ(irq_n); if (all_disabled) NVIC_DisableIRQ(irq_n);
@ -276,41 +282,49 @@ void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
int serial_getc(serial_t *obj) int serial_getc(serial_t *obj)
{ {
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); USART_TypeDef *uart = (USART_TypeDef *)(obj->uart);
while (!serial_readable(obj)); while (!serial_readable(obj));
return (int)(USART_ReceiveData(usart)); if (obj->databits == UART_WORDLENGTH_8B) {
return (int)(uart->DR & (uint8_t)0xFF);
} else {
return (int)(uart->DR & (uint16_t)0x1FF);
}
} }
void serial_putc(serial_t *obj, int c) void serial_putc(serial_t *obj, int c)
{ {
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); USART_TypeDef *uart = (USART_TypeDef *)(obj->uart);
while (!serial_writable(obj)); while (!serial_writable(obj));
USART_SendData(usart, (uint16_t)c); if (obj->databits == UART_WORDLENGTH_8B) {
uart->DR = (uint8_t)(c & (uint8_t)0xFF);
} else {
uart->DR = (uint16_t)(c & (uint16_t)0x1FF);
}
} }
int serial_readable(serial_t *obj) int serial_readable(serial_t *obj)
{ {
int status; int status;
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); UartHandle.Instance = (USART_TypeDef *)(obj->uart);
// Check if data is received // Check if data is received
status = ((USART_GetFlagStatus(usart, USART_FLAG_RXNE) != RESET) ? 1 : 0); status = ((__HAL_UART_GET_FLAG(&UartHandle, UART_FLAG_RXNE) != RESET) ? 1 : 0);
return status; return status;
} }
int serial_writable(serial_t *obj) int serial_writable(serial_t *obj)
{ {
int status; int status;
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); UartHandle.Instance = (USART_TypeDef *)(obj->uart);
// Check if data is transmitted // Check if data is transmitted
status = ((USART_GetFlagStatus(usart, USART_FLAG_TXE) != RESET) ? 1 : 0); status = ((__HAL_UART_GET_FLAG(&UartHandle, UART_FLAG_TXE) != RESET) ? 1 : 0);
return status; return status;
} }
void serial_clear(serial_t *obj) void serial_clear(serial_t *obj)
{ {
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); UartHandle.Instance = (USART_TypeDef *)(obj->uart);
USART_ClearFlag(usart, USART_FLAG_TXE); __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_TXE);
USART_ClearFlag(usart, USART_FLAG_RXNE); __HAL_UART_CLEAR_FLAG(&UartHandle, UART_FLAG_RXNE);
} }
void serial_pinout_tx(PinName tx) void serial_pinout_tx(PinName tx)
@ -320,8 +334,8 @@ void serial_pinout_tx(PinName tx)
void serial_break_set(serial_t *obj) void serial_break_set(serial_t *obj)
{ {
USART_TypeDef *usart = (USART_TypeDef *)(obj->uart); UartHandle.Instance = (USART_TypeDef *)(obj->uart);
USART_SendBreak(usart); HAL_LIN_SendBreak(&UartHandle);
} }
void serial_break_clear(serial_t *obj) void serial_break_clear(serial_t *obj)

28
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/sleep.c
View File

@ -32,35 +32,31 @@
#if DEVICE_SLEEP #if DEVICE_SLEEP
#include "cmsis.h" #include "cmsis.h"
#include "hal_tick.h"
static TIM_HandleTypeDef TimMasterHandle;
void sleep(void) void sleep(void)
{ {
// Disable us_ticker update interrupt TimMasterHandle.Instance = TIM_MST;
TIM_ITConfig(TIM1, TIM_IT_Update, DISABLE);
SCB->SCR = 0; // Normal sleep mode for ARM core // Disable HAL tick and us_ticker update interrupts
__WFI(); __HAL_TIM_DISABLE_IT(&TimMasterHandle, (TIM_IT_CC2 | TIM_IT_UPDATE));
// Re-enable us_ticker update interrupt // Request to enter SLEEP mode
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE); HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
// Enable HAL tick and us_ticker update interrupts
__HAL_TIM_ENABLE_IT(&TimMasterHandle, (TIM_IT_CC2 | TIM_IT_UPDATE));
} }
void deepsleep(void) void deepsleep(void)
{ {
// Disable us_ticker update interrupt
TIM_ITConfig(TIM1, TIM_IT_Update, DISABLE);
// Enable PWR clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
// Request to enter STOP mode with regulator in low power mode // Request to enter STOP mode with regulator in low power mode
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI); HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
// After wake-up from STOP reconfigure the PLL // After wake-up from STOP reconfigure the PLL
SetSysClock(); SetSysClock();
// Re-enable us_ticker update interrupt
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
} }
#endif #endif

183
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/spi_api.c
View File

@ -37,25 +37,29 @@
#include "pinmap.h" #include "pinmap.h"
#include "PeripheralPins.h" #include "PeripheralPins.h"
static SPI_HandleTypeDef SpiHandle;
static void init_spi(spi_t *obj) static void init_spi(spi_t *obj)
{ {
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
SPI_InitTypeDef SPI_InitStructure;
SPI_Cmd(spi, DISABLE); __HAL_SPI_DISABLE(&SpiHandle);
SPI_InitStructure.SPI_Mode = obj->mode; SpiHandle.Init.Mode = obj->mode;
SPI_InitStructure.SPI_NSS = obj->nss; SpiHandle.Init.BaudRatePrescaler = obj->br_presc;
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; SpiHandle.Init.Direction = SPI_DIRECTION_2LINES;
SPI_InitStructure.SPI_DataSize = obj->bits; SpiHandle.Init.CLKPhase = obj->cpha;
SPI_InitStructure.SPI_CPOL = obj->cpol; SpiHandle.Init.CLKPolarity = obj->cpol;
SPI_InitStructure.SPI_CPHA = obj->cpha; SpiHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLED;
SPI_InitStructure.SPI_BaudRatePrescaler = obj->br_presc; SpiHandle.Init.CRCPolynomial = 7;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; SpiHandle.Init.DataSize = obj->bits;
SPI_InitStructure.SPI_CRCPolynomial = 7; SpiHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;
SPI_Init(spi, &SPI_InitStructure); SpiHandle.Init.NSS = obj->nss;
SpiHandle.Init.TIMode = SPI_TIMODE_DISABLED;
SPI_Cmd(spi, ENABLE); HAL_SPI_Init(&SpiHandle);
__HAL_SPI_ENABLE(&SpiHandle);
} }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
@ -74,10 +78,10 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
// Enable SPI clock // Enable SPI clock
if (obj->spi == SPI_1) { if (obj->spi == SPI_1) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); __SPI1_CLK_ENABLE();
} }
if (obj->spi == SPI_2) { if (obj->spi == SPI_2) {
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE); __SPI2_CLK_ENABLE();
} }
// Configure the SPI pins // Configure the SPI pins
@ -86,23 +90,23 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
pinmap_pinout(sclk, PinMap_SPI_SCLK); pinmap_pinout(sclk, PinMap_SPI_SCLK);
// Save new values // Save new values
obj->bits = SPI_DataSize_8b; obj->bits = SPI_DATASIZE_8BIT;
obj->cpol = SPI_CPOL_Low; obj->cpol = SPI_POLARITY_LOW;
obj->cpha = SPI_CPHA_1Edge; obj->cpha = SPI_PHASE_1EDGE;
obj->br_presc = SPI_BaudRatePrescaler_256; obj->br_presc = SPI_BAUDRATEPRESCALER_256;
obj->pin_miso = miso; obj->pin_miso = miso;
obj->pin_mosi = mosi; obj->pin_mosi = mosi;
obj->pin_sclk = sclk; obj->pin_sclk = sclk;
obj->pin_ssel = ssel; obj->pin_ssel = ssel;
if (ssel == NC) { // Master if (ssel == NC) { // SW NSS Master mode
obj->mode = SPI_Mode_Master; obj->mode = SPI_MODE_MASTER;
obj->nss = SPI_NSS_Soft; obj->nss = SPI_NSS_SOFT;
} else { // Slave } else { // Slave
pinmap_pinout(ssel, PinMap_SPI_SSEL); pinmap_pinout(ssel, PinMap_SPI_SSEL);
obj->mode = SPI_Mode_Slave; obj->mode = SPI_MODE_SLAVE;
obj->nss = SPI_NSS_Hard; obj->nss = SPI_NSS_HARD_INPUT;
} }
init_spi(obj); init_spi(obj);
@ -112,58 +116,58 @@ void spi_free(spi_t *obj)
{ {
// Reset SPI and disable clock // Reset SPI and disable clock
if (obj->spi == SPI_1) { if (obj->spi == SPI_1) {
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE); __SPI1_FORCE_RESET();
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE); __SPI1_RELEASE_RESET();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, DISABLE); __SPI1_CLK_DISABLE();
} }
if (obj->spi == SPI_2) { if (obj->spi == SPI_2) {
RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE); __SPI2_FORCE_RESET();
RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, DISABLE); __SPI2_RELEASE_RESET();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, DISABLE); __SPI2_CLK_DISABLE();
} }
// Configure GPIOs // Configure GPIOs
pin_function(obj->pin_miso, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_miso, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(obj->pin_mosi, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_mosi, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(obj->pin_sclk, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_sclk, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
pin_function(obj->pin_ssel, STM_PIN_DATA(GPIO_Mode_IN_FLOATING, 0)); pin_function(obj->pin_ssel, STM_PIN_DATA(STM_MODE_INPUT, GPIO_NOPULL, 0));
} }
void spi_format(spi_t *obj, int bits, int mode, int slave) void spi_format(spi_t *obj, int bits, int mode, int slave)
{ {
// Save new values // Save new values
if (bits == 16) { if (bits == 16) {
obj->bits = SPI_DataSize_16b; obj->bits = SPI_DATASIZE_16BIT;
} else { } else {
obj->bits = SPI_DataSize_8b; obj->bits = SPI_DATASIZE_8BIT;
} }
switch (mode) { switch (mode) {
case 0: case 0:
obj->cpol = SPI_CPOL_Low; obj->cpol = SPI_POLARITY_LOW;
obj->cpha = SPI_CPHA_1Edge; obj->cpha = SPI_PHASE_1EDGE;
break; break;
case 1: case 1:
obj->cpol = SPI_CPOL_Low; obj->cpol = SPI_POLARITY_LOW;
obj->cpha = SPI_CPHA_2Edge; obj->cpha = SPI_PHASE_2EDGE;
break; break;
case 2: case 2:
obj->cpol = SPI_CPOL_High; obj->cpol = SPI_POLARITY_HIGH;
obj->cpha = SPI_CPHA_1Edge; obj->cpha = SPI_PHASE_1EDGE;
break; break;
default: default:
obj->cpol = SPI_CPOL_High; obj->cpol = SPI_POLARITY_HIGH;
obj->cpha = SPI_CPHA_2Edge; obj->cpha = SPI_PHASE_2EDGE;
break; break;
} }
if (slave == 0) { if (slave == 0) {
obj->mode = SPI_Mode_Master; obj->mode = SPI_MODE_MASTER;
obj->nss = SPI_NSS_Soft; obj->nss = SPI_NSS_SOFT;
} else { } else {
obj->mode = SPI_Mode_Slave; obj->mode = SPI_MODE_SLAVE;
obj->nss = SPI_NSS_Hard; obj->nss = SPI_NSS_HARD_INPUT;
} }
init_spi(obj); init_spi(obj);
@ -174,42 +178,42 @@ void spi_frequency(spi_t *obj, int hz)
if (obj->spi == SPI_1) { if (obj->spi == SPI_1) {
// Values depend of PCLK2: 64 MHz if HSI is used, 72 MHz if HSE is used // Values depend of PCLK2: 64 MHz if HSI is used, 72 MHz if HSE is used
if (hz < 500000) { if (hz < 500000) {
obj->br_presc = SPI_BaudRatePrescaler_256; // 250 kHz - 281 kHz obj->br_presc = SPI_BAUDRATEPRESCALER_256; // 250 kHz - 281 kHz
} else if ((hz >= 500000) && (hz < 1000000)) { } else if ((hz >= 500000) && (hz < 1000000)) {
obj->br_presc = SPI_BaudRatePrescaler_128; // 500 kHz - 563 kHz obj->br_presc = SPI_BAUDRATEPRESCALER_128; // 500 kHz - 563 kHz
} else if ((hz >= 1000000) && (hz < 2000000)) { } else if ((hz >= 1000000) && (hz < 2000000)) {
obj->br_presc = SPI_BaudRatePrescaler_64; // 1 MHz - 1.13 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_64; // 1 MHz - 1.13 MHz
} else if ((hz >= 2000000) && (hz < 4000000)) { } else if ((hz >= 2000000) && (hz < 4000000)) {
obj->br_presc = SPI_BaudRatePrescaler_32; // 2 MHz - 2.25 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_32; // 2 MHz - 2.25 MHz
} else if ((hz >= 4000000) && (hz < 8000000)) { } else if ((hz >= 4000000) && (hz < 8000000)) {
obj->br_presc = SPI_BaudRatePrescaler_16; // 4 MHz - 4.5 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_16; // 4 MHz - 4.5 MHz
} else if ((hz >= 8000000) && (hz < 16000000)) { } else if ((hz >= 8000000) && (hz < 16000000)) {
obj->br_presc = SPI_BaudRatePrescaler_8; // 8 MHz - 9 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_8; // 8 MHz - 9 MHz
} else if ((hz >= 16000000) && (hz < 32000000)) { } else if ((hz >= 16000000) && (hz < 32000000)) {
obj->br_presc = SPI_BaudRatePrescaler_4; // 16 MHz - 18 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_4; // 16 MHz - 18 MHz
} else { // >= 32000000 } else { // >= 32000000
obj->br_presc = SPI_BaudRatePrescaler_2; // 32 MHz - 36 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_2; // 32 MHz - 36 MHz
} }
} }
if (obj->spi == SPI_2) { if (obj->spi == SPI_2) {
// Values depend of PCLK1: 32 MHz if HSI is used, 36 MHz if HSE is used // Values depend of PCLK1: 32 MHz if HSI is used, 36 MHz if HSE is used
if (hz < 250000) { if (hz < 250000) {
obj->br_presc = SPI_BaudRatePrescaler_256; // 125 kHz - 141 kHz obj->br_presc = SPI_BAUDRATEPRESCALER_256; // 125 kHz - 141 kHz
} else if ((hz >= 250000) && (hz < 500000)) { } else if ((hz >= 250000) && (hz < 500000)) {
obj->br_presc = SPI_BaudRatePrescaler_128; // 250 kHz - 281 kHz obj->br_presc = SPI_BAUDRATEPRESCALER_128; // 250 kHz - 281 kHz
} else if ((hz >= 500000) && (hz < 1000000)) { } else if ((hz >= 500000) && (hz < 1000000)) {
obj->br_presc = SPI_BaudRatePrescaler_64; // 500 kHz - 563 kHz obj->br_presc = SPI_BAUDRATEPRESCALER_64; // 500 kHz - 563 kHz
} else if ((hz >= 1000000) && (hz < 2000000)) { } else if ((hz >= 1000000) && (hz < 2000000)) {
obj->br_presc = SPI_BaudRatePrescaler_32; // 1 MHz - 1.13 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_32; // 1 MHz - 1.13 MHz
} else if ((hz >= 2000000) && (hz < 4000000)) { } else if ((hz >= 2000000) && (hz < 4000000)) {
obj->br_presc = SPI_BaudRatePrescaler_16; // 2 MHz - 2.25 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_16; // 2 MHz - 2.25 MHz
} else if ((hz >= 4000000) && (hz < 8000000)) { } else if ((hz >= 4000000) && (hz < 8000000)) {
obj->br_presc = SPI_BaudRatePrescaler_8; // 4 MHz - 4.5 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_8; // 4 MHz - 4.5 MHz
} else if ((hz >= 8000000) && (hz < 16000000)) { } else if ((hz >= 8000000) && (hz < 16000000)) {
obj->br_presc = SPI_BaudRatePrescaler_4; // 8 MHz - 9 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_4; // 8 MHz - 9 MHz
} else { // >= 16000000 } else { // >= 16000000
obj->br_presc = SPI_BaudRatePrescaler_2; // 16 MHz - 18 MHz obj->br_presc = SPI_BAUDRATEPRESCALER_2; // 16 MHz - 18 MHz
} }
} }
@ -219,18 +223,18 @@ void spi_frequency(spi_t *obj, int hz)
static inline int ssp_readable(spi_t *obj) static inline int ssp_readable(spi_t *obj)
{ {
int status; int status;
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
// Check if data is received // Check if data is received
status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_RXNE) != RESET) ? 1 : 0); status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_RXNE) != RESET) ? 1 : 0);
return status; return status;
} }
static inline int ssp_writeable(spi_t *obj) static inline int ssp_writeable(spi_t *obj)
{ {
int status; int status;
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
// Check if data is transmitted // Check if data is transmitted
status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_TXE) != RESET) ? 1 : 0); status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_TXE) != RESET) ? 1 : 0);
return status; return status;
} }
@ -238,21 +242,35 @@ static inline void ssp_write(spi_t *obj, int value)
{ {
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
while (!ssp_writeable(obj)); while (!ssp_writeable(obj));
SPI_I2S_SendData(spi, (uint16_t)value); if (obj->bits == SPI_DATASIZE_8BIT) {
// Force 8-bit access to the data register
uint8_t *p_spi_dr = 0;
p_spi_dr = (uint8_t *) & (spi->DR);
*p_spi_dr = (uint8_t)value;
} else { // SPI_DATASIZE_16BIT
spi->DR = (uint16_t)value;
}
} }
static inline int ssp_read(spi_t *obj) static inline int ssp_read(spi_t *obj)
{ {
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
while (!ssp_readable(obj)); while (!ssp_readable(obj));
return (int)SPI_I2S_ReceiveData(spi); if (obj->bits == SPI_DATASIZE_8BIT) {
// Force 8-bit access to the data register
uint8_t *p_spi_dr = 0;
p_spi_dr = (uint8_t *) & (spi->DR);
return (int)(*p_spi_dr);
} else {
return (int)spi->DR;
}
} }
static inline int ssp_busy(spi_t *obj) static inline int ssp_busy(spi_t *obj)
{ {
int status; int status;
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SpiHandle.Instance = (SPI_TypeDef *)(obj->spi);
status = ((SPI_I2S_GetFlagStatus(spi, SPI_I2S_FLAG_BSY) != RESET) ? 1 : 0); status = ((__HAL_SPI_GET_FLAG(&SpiHandle, SPI_FLAG_BSY) != RESET) ? 1 : 0);
return status; return status;
} }
@ -270,14 +288,29 @@ int spi_slave_receive(spi_t *obj)
int spi_slave_read(spi_t *obj) int spi_slave_read(spi_t *obj)
{ {
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
return (int)SPI_I2S_ReceiveData(spi); while (!ssp_readable(obj));
if (obj->bits == SPI_DATASIZE_8BIT) {
// Force 8-bit access to the data register
uint8_t *p_spi_dr = 0;
p_spi_dr = (uint8_t *) & (spi->DR);
return (int)(*p_spi_dr);
} else {
return (int)spi->DR;
}
} }
void spi_slave_write(spi_t *obj, int value) void spi_slave_write(spi_t *obj, int value)
{ {
SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi); SPI_TypeDef *spi = (SPI_TypeDef *)(obj->spi);
while (!ssp_writeable(obj)); while (!ssp_writeable(obj));
SPI_I2S_SendData(spi, (uint16_t)value); if (obj->bits == SPI_DATASIZE_8BIT) {
// Force 8-bit access to the data register
uint8_t *p_spi_dr = 0;
p_spi_dr = (uint8_t *) & (spi->DR);
*p_spi_dr = (uint8_t)value;
} else { // SPI_DATASIZE_16BIT
spi->DR = (uint16_t)value;
}
} }
int spi_busy(spi_t *obj) int spi_busy(spi_t *obj)

75
libraries/mbed/targets/hal/TARGET_STM/TARGET_NUCLEO_F103RB/us_ticker.c
View File

@ -29,78 +29,31 @@
#include "us_ticker_api.h" #include "us_ticker_api.h"
#include "PeripheralNames.h" #include "PeripheralNames.h"
// Timer selection: // Timer selection
#define TIM_MST TIM4 #define TIM_MST TIM4
#define TIM_MST_IRQ TIM4_IRQn
#define TIM_MST_RCC RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE)
static TIM_HandleTypeDef TimMasterHandle;
static int us_ticker_inited = 0; static int us_ticker_inited = 0;
static volatile uint32_t SlaveCounter = 0;
static volatile uint32_t oc_int_part = 0; volatile uint32_t SlaveCounter = 0;
static volatile uint16_t oc_rem_part = 0; volatile uint32_t oc_int_part = 0;
volatile uint16_t oc_rem_part = 0;
void set_compare(uint16_t count) void set_compare(uint16_t count)
{ {
TimMasterHandle.Instance = TIM_MST;
// Set new output compare value // Set new output compare value
TIM_SetCompare1(TIM_MST, count); __HAL_TIM_SetCompare(&TimMasterHandle, TIM_CHANNEL_1, count);
// Enable IT // Enable IT
TIM_ITConfig(TIM_MST, TIM_IT_CC1, ENABLE); __HAL_TIM_ENABLE_IT(&TimMasterHandle, TIM_IT_CC1);
}
static void tim_irq_handler(void)
{
uint16_t cval = TIM_MST->CNT;
if (TIM_GetITStatus(TIM_MST, TIM_IT_Update) == SET) {
TIM_ClearITPendingBit(TIM_MST, TIM_IT_Update);
SlaveCounter++;
}
if (TIM_GetITStatus(TIM_MST, TIM_IT_CC1) == SET) {
TIM_ClearITPendingBit(TIM_MST, TIM_IT_CC1);
if (oc_rem_part > 0) {
set_compare(oc_rem_part); // Finish the remaining time left
oc_rem_part = 0;
} else {
if (oc_int_part > 0) {
set_compare(0xFFFF);
oc_rem_part = cval; // To finish the counter loop the next time
oc_int_part--;
} else {
us_ticker_irq_handler();
}
}
}
} }
void us_ticker_init(void) void us_ticker_init(void)
{ {
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
if (us_ticker_inited) return; if (us_ticker_inited) return;
us_ticker_inited = 1; us_ticker_inited = 1;
// Enable timer clock HAL_InitTick(0); // The passed value is not used
TIM_MST_RCC;
// Configure time base
TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
TIM_TimeBaseStructure.TIM_Period = 0xFFFF;
TIM_TimeBaseStructure.TIM_Prescaler = (uint16_t)(SystemCoreClock / 1000000) - 1; // 1 <20>s tick
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM_MST, &TIM_TimeBaseStructure);
// Configure interrupts
TIM_ITConfig(TIM_MST, TIM_IT_Update, ENABLE);
// Update interrupt used for 32-bit counter
// Output compare interrupt used for timeout feature
NVIC_SetVector(TIM_MST_IRQ, (uint32_t)tim_irq_handler);
NVIC_EnableIRQ(TIM_MST_IRQ);
// Enable timer
TIM_Cmd(TIM_MST, ENABLE);
} }
uint32_t us_ticker_read() uint32_t us_ticker_read()
@ -147,10 +100,14 @@ void us_ticker_set_interrupt(timestamp_t timestamp)
void us_ticker_disable_interrupt(void) void us_ticker_disable_interrupt(void)
{ {
TIM_ITConfig(TIM_MST, TIM_IT_CC1, DISABLE); TimMasterHandle.Instance = TIM_MST;
__HAL_TIM_DISABLE_IT(&TimMasterHandle, TIM_IT_CC1);
} }
void us_ticker_clear_interrupt(void) void us_ticker_clear_interrupt(void)
{ {
TIM_ClearITPendingBit(TIM_MST, TIM_IT_CC1); TimMasterHandle.Instance = TIM_MST;
if (__HAL_TIM_GET_FLAG(&TimMasterHandle, TIM_FLAG_CC1) == SET) {
__HAL_TIM_CLEAR_FLAG(&TimMasterHandle, TIM_FLAG_CC1);
}
} }