RT-Thread 基于STM32F1xx HAL 库的学习笔记(2)---加入pin功能支持

RT-Thread的pin功能是个有意思的功能，在系统注册成misc之后，可以在进程中对芯片的IO引脚进行配置和读写。

虽然在components\drivers\misc目录下pin.c中实现了中间的驱动，但是没底层驱动是难以发挥其功能的，这里就学习下如何通过底层驱动来实现在进程中进行pin操作。

在rt-thread-2.1.0\bsp\stm32f40x\drivers目录中有基于stm32f4xx系列的关于pin操作的底层驱动，这是基于STM32F4xx_StdPeriph_Driver标准库的，所以需要移植才能拿来用。

【1】复制rt-thread-2.1.0\bsp\stm32f40x\drivers目录下的gpio.c和gpio.h到\rt-thread-2.1.0\bsp\stm32f10x-curer\drivers目录下，并重命名为drv_gpio.c和drv_gpio.h 。

【2】打开rtconfig.h，加入RT_USING_PIN功能选项，修改如下：

#define RT_USING_UART1
#define RT_USING_UART2
//#define RT_USING_UART3

/*Using Pin select as device*/
#define RT_USING_PIN

/* SECTION: Console options */
#define RT_USING_CONSOLE

【3】打开drv_gpio.c文件，修改如下：
#include <rthw.h>
#include <rtdevice.h>
#include <board.h>
#include <drv_gpio.h>
#include <drivers/pin.h>

#ifdef RT_USING_PIN

#define STM32F10X_PIN_NUMBERS 144 //[ 64, 100, 144 ]

#define __STM32_PIN(index, /*rcc,*/ x, pin_index) { 0, /*RCC_##rcc##Periph_GPIO##gpio,*/ GPIO##x, GPIO_PIN_##pin_index}
#define __STM32_PIN_DEFAULT {-1, /*0,*/ 0, 0}

/* STM32 GPIO driver */
struct pin_index
{
int index;
//uint32_t rcc;
GPIO_TypeDef *gpio;
uint32_t pin;
};

static const struct pin_index pins[] =
{
#if (STM32F10X_PIN_NUMBERS == 64)
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(2, /*APB2,*/ C, 13),
__STM32_PIN(3, /*APB2,*/ C, 14),
__STM32_PIN(4, /*APB2,*/ C, 15),
__STM32_PIN(5, /*APB2,*/ D, 0),
__STM32_PIN(6, /*APB2,*/ D, 1),
__STM32_PIN_DEFAULT,
__STM32_PIN(8, /*APB2,*/ C, 0),
__STM32_PIN(9, /*APB2,*/ C, 1),
__STM32_PIN(10,/*APB2,*/ C, 2),
__STM32_PIN(11,/*APB2,*/ C, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(14, /*APB2,*/ A, 0),
__STM32_PIN(15, /*APB2,*/ A, 1),
__STM32_PIN(16, /*APB2,*/ A, 2),
__STM32_PIN(17, /*APB2,*/ A, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(20, /*APB2,*/ A, 4),
__STM32_PIN(21, /*APB2,*/ A, 5),
__STM32_PIN(22, /*APB2,*/ A, 6),
__STM32_PIN(23, /*APB2,*/ A, 7),
__STM32_PIN(24, /*APB2,*/ C, 4),
__STM32_PIN(25, /*APB2,*/ C, 5),
__STM32_PIN(26, /*APB2,*/ B, 0),
__STM32_PIN(27, /*APB2,*/ B, 1),
__STM32_PIN(28, /*APB2,*/ B, 2),
__STM32_PIN(29, /*APB2,*/ B, 10),
__STM32_PIN(30, /*APB2,*/ B, 11),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(33, /*APB2,*/ B, 12),
__STM32_PIN(34, /*APB2,*/ B, 13),
__STM32_PIN(35, /*APB2,*/ B, 14),
__STM32_PIN(36, /*APB2,*/ B, 15),
__STM32_PIN(37, /*APB2,*/ C, 6),
__STM32_PIN(38, /*APB2,*/ C, 7),
__STM32_PIN(39, /*APB2,*/ C, 8),
__STM32_PIN(40, /*APB2,*/ C, 9),
__STM32_PIN(41, /*APB2,*/ A, 8),
__STM32_PIN(42, /*APB2,*/ A, 9),
__STM32_PIN(43, /*APB2,*/ A, 10),
__STM32_PIN(44, /*APB2,*/ A, 11),
__STM32_PIN(45, /*APB2,*/ A, 12),
__STM32_PIN(46, /*APB2,*/ A, 13),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(49, /*APB2,*/ A, 14),
__STM32_PIN(50, /*APB2,*/ A, 15),
__STM32_PIN(51, /*APB2,*/ C, 10),
__STM32_PIN(52, /*APB2,*/ C, 11),
__STM32_PIN(53, /*APB2,*/ C, 12),
__STM32_PIN(54, /*APB2,*/ D, 2),
__STM32_PIN(55, /*APB2, */B, 3),
__STM32_PIN(56, /*APB2,*/ B, 4),
__STM32_PIN(57, /*APB2,*/ B, 5),
__STM32_PIN(58, /*APB2,*/ B, 6),
__STM32_PIN(59, /*APB2,*/ B, 7),
__STM32_PIN_DEFAULT,
__STM32_PIN(61, /*APB2,*/ B, 8),
__STM32_PIN(62, /*APB2,*/ B, 9),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
#endif
#if (STM32F10X_PIN_NUMBERS == 100)
__STM32_PIN_DEFAULT,
__STM32_PIN(1, /*APB2,*/ E, 2),
__STM32_PIN(2, /*APB2,*/ E, 3),
__STM32_PIN(3, /*APB2,*/ E, 4),
__STM32_PIN(4, /*APB2,*/ E, 5),
__STM32_PIN(5, /*APB2,*/ E, 6),
__STM32_PIN_DEFAULT,
__STM32_PIN(7, /*APB2,*/ C, 13),
__STM32_PIN(8, /*APB2,*/ C, 14),
__STM32_PIN(9, /*APB2,*/ C, 15),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(15, /*APB2,*/ C, 0),
__STM32_PIN(16, /*APB2,*/ C, 1),
__STM32_PIN(17, /*APB2,*/ C, 2),
__STM32_PIN(18, /*APB2,*/ C, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(23, /*APB2,*/ A, 0),
__STM32_PIN(24, /*APB2,*/ A, 1),
__STM32_PIN(25, /*APB2,*/ A, 2),
__STM32_PIN(26, /*APB2,*/ A, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(29, /*APB2,*/ A, 4),
__STM32_PIN(30, /*APB2,*/ A, 5),
__STM32_PIN(31, /*APB2,*/ A, 6),
__STM32_PIN(32, /*APB2,*/ A, 7),
__STM32_PIN(33, /*APB2,*/ C, 4),
__STM32_PIN(34, /*APB2,*/ C, 5),
__STM32_PIN(35, /*APB2,*/ B, 0),
__STM32_PIN(36, /*APB2,*/ B, 1),
__STM32_PIN(37, /*APB2,*/ B, 2),
__STM32_PIN(38, /*APB2,*/ E, 7),
__STM32_PIN(39, /*APB2,*/ E, 8),
__STM32_PIN(40, /*APB2,*/ E, 9),
__STM32_PIN(41, /*APB2,*/ E, 10),
__STM32_PIN(42, /*APB2,*/ E, 11),
__STM32_PIN(43, /*APB2,*/ E, 12),
__STM32_PIN(44, /*APB2,*/ E, 13),
__STM32_PIN(45, /*APB2,*/ E, 14),
__STM32_PIN(46, /*APB2,*/ E, 15),
__STM32_PIN(47, /*APB2,*/ B, 10),
__STM32_PIN(48, /*APB2,*/ B, 11),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(51, /*APB2,*/ B, 12),
__STM32_PIN(52, /*APB2,*/ B, 13),
__STM32_PIN(53, /*APB2,*/ B, 14),
__STM32_PIN(54, /*APB2,*/ B, 15),
__STM32_PIN(55, /*APB2,*/ D, 8),
__STM32_PIN(56, /*APB2,*/ D, 9),
__STM32_PIN(57, /*APB2,*/ D, 10),
__STM32_PIN(58, /*APB2,*/ D, 11),
__STM32_PIN(59, /*APB2,*/ D, 12),
__STM32_PIN(60, /*APB2,*/ D, 13),
__STM32_PIN(61, /*APB2,*/ D, 14),
__STM32_PIN(62, /*APB2,*/ D, 15),
__STM32_PIN(63, /*APB2,*/ C, 6),
__STM32_PIN(64, /*APB2,*/ C, 7),
__STM32_PIN(65, /*APB2,*/ C, 8),
__STM32_PIN(66, /*APB2,*/ C, 9),
__STM32_PIN(67, /*APB2,*/ A, 8),
__STM32_PIN(68, /*APB2,*/ A, 9),
__STM32_PIN(69, /*APB2,*/ A, 10),
__STM32_PIN(70, /*APB2,*/ A, 11),
__STM32_PIN(71, /*APB2,*/ A, 12),
__STM32_PIN(72, /*APB2,*/ A, 13),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(76, /*APB2,*/ A, 14),
__STM32_PIN(77, /*APB2,*/ A, 15),
__STM32_PIN(78, /*APB2,*/ C, 10),
__STM32_PIN(79, /*APB2,*/ C, 11),
__STM32_PIN(80, /*APB2,*/ C, 12),
__STM32_PIN(81, /*APB2,*/ D, 0),
__STM32_PIN(82, /*APB2,*/ D, 1),
__STM32_PIN(83, /*APB2,*/ D, 2),
__STM32_PIN(84, /*APB2,*/ D, 3),
__STM32_PIN(85, /*APB2,*/ D, 4),
__STM32_PIN(86, /*APB2,*/ D, 5),
__STM32_PIN(87, /*APB2,*/ D, 6),
__STM32_PIN(88, /*APB2,*/ D, 7),
__STM32_PIN(89, /*APB2,*/ B, 3),
__STM32_PIN(90, /*APB2,*/ B, 4),
__STM32_PIN(91, /*APB2,*/ B, 5),
__STM32_PIN(92, /*APB2,*/ B, 6),
__STM32_PIN(93, /*APB2,*/ B, 7),
__STM32_PIN_DEFAULT,
__STM32_PIN(95, /*APB2,*/ B, 8),
__STM32_PIN(96, /*APB2,*/ B, 9),
__STM32_PIN(97, /*APB2,*/ E, 0),
__STM32_PIN(98, /*APB2,*/ E, 1),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
#endif
#if (STM32F10X_PIN_NUMBERS == 144)
__STM32_PIN_DEFAULT,
__STM32_PIN(1, /*APB2,*/ E, 2),
__STM32_PIN(2, /*APB2,*/ E, 3),
__STM32_PIN(3, /*APB2,*/ E, 4),
__STM32_PIN(4, /*APB2,*/ E, 5),
__STM32_PIN(5, /*APB2,*/ E, 6),
__STM32_PIN_DEFAULT,
__STM32_PIN(7, /*APB2,*/ C, 13),
__STM32_PIN(8, /*APB2,*/ C, 14),
__STM32_PIN(9, /*APB2,*/ C, 15),

__STM32_PIN(10, /*APB2,*/ F, 0),
__STM32_PIN(11, /*APB2,*/ F, 1),
__STM32_PIN(12, /*APB2,*/ F, 2),
__STM32_PIN(13, /*APB2,*/ F, 3),
__STM32_PIN(14, /*APB2,*/ F, 4),
__STM32_PIN(15, /*APB2,*/ F, 5),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(18, /*APB2,*/ F, 6),
__STM32_PIN(19, /*APB2,*/ F, 7),
__STM32_PIN(20, /*APB2,*/ F, 8),
__STM32_PIN(21, /*APB2,*/ F, 9),
__STM32_PIN(22, /*APB2,*/ F, 10),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(26, /*APB2,*/ C, 0),
__STM32_PIN(27, /*APB2,*/ C, 1),
__STM32_PIN(28, /*APB2,*/ C, 2),
__STM32_PIN(29, /*APB2,*/ C, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(34, /*APB2,*/ A, 0),
__STM32_PIN(35, /*APB2,*/ A, 1),
__STM32_PIN(36, /*APB2,*/ A, 2),
__STM32_PIN(37, /*APB2,*/ A, 3),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(40, /*APB2,*/ A, 4),
__STM32_PIN(41, /*APB2,*/ A, 5),
__STM32_PIN(42, /*APB2,*/ A, 6),
__STM32_PIN(43, /*APB2,*/ A, 7),
__STM32_PIN(44, /*APB2,*/ C, 4),
__STM32_PIN(45, /*APB2,*/ C, 5),
__STM32_PIN(46, /*APB2,*/ B, 0),
__STM32_PIN(47, /*APB2,*/ B, 1),
__STM32_PIN(48, /*APB2,*/ B, 2),
__STM32_PIN(49, /*APB2,*/ F, 11),
__STM32_PIN(50, /*APB2,*/ F, 12),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(53, /*APB2,*/ F, 13),
__STM32_PIN(54, /*APB2,*/ F, 14),
__STM32_PIN(55, /*APB2,*/ F, 15),
__STM32_PIN(56, /*APB2,*/ G, 0),
__STM32_PIN(57, /*APB2,*/ G, 1),
__STM32_PIN(58, /*APB2,*/ E, 7),
__STM32_PIN(59, /*APB2,*/ E, 8),
__STM32_PIN(60, /*APB2,*/ E, 9),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(63, /*APB2,*/ E, 10),
__STM32_PIN(64, /*APB2,*/ E, 11),
__STM32_PIN(65, /*APB2,*/ E, 12),
__STM32_PIN(66, /*APB2,*/ E, 13),
__STM32_PIN(67, /*APB2,*/ E, 14),
__STM32_PIN(68, /*APB2,*/ E, 15),
__STM32_PIN(69, /*APB2,*/ B, 10),
__STM32_PIN(70, /*APB2,*/ B, 11),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(73, /*APB2,*/ B, 12),
__STM32_PIN(74, /*APB2,*/ B, 13),
__STM32_PIN(75, /*APB2,*/ B, 14),
__STM32_PIN(76, /*APB2,*/ B, 15),
__STM32_PIN(77, /*APB2,*/ D, 8),
__STM32_PIN(78, /*APB2,*/ D, 9),
__STM32_PIN(79, /*APB2,*/ D, 10),
__STM32_PIN(80, /*APB2,*/ D, 11),
__STM32_PIN(81, /*APB2,*/ D, 12),
__STM32_PIN(82, /*APB2,*/ D, 13),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(85, /*APB2,*/ D, 14),
__STM32_PIN(86, /*APB2,*/ D, 15),
__STM32_PIN(87, /*APB2,*/ G, 2),
__STM32_PIN(88, /*APB2,*/ G, 3),
__STM32_PIN(89, /*APB2,*/ G, 4),
__STM32_PIN(90, /*APB2,*/ G, 5),
__STM32_PIN(91, /*APB2,*/ G, 6),
__STM32_PIN(92, /*APB2,*/ G, 7),
__STM32_PIN(93, /*APB2,*/ G, 8),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(96, /*APB2,*/ C, 6),
__STM32_PIN(97, /*APB2,*/ C, 7),
__STM32_PIN(98, /*APB2,*/ C, 8),
__STM32_PIN(99, /*APB2,*/ C, 9),
__STM32_PIN(100, /*APB2,*/ A, 8),
__STM32_PIN(101, /*APB2,*/ A, 9),
__STM32_PIN(102, /*APB2,*/ A, 10),
__STM32_PIN(103, /*APB2,*/ A, 11),
__STM32_PIN(104, /*APB2,*/ A, 12),
__STM32_PIN(105, /*APB2,*/ A, 13),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(109, /*APB2,*/ A, 14),
__STM32_PIN(110, /*APB2,*/ A, 15),
__STM32_PIN(111, /*APB2,*/ C, 10),
__STM32_PIN(112, /*APB2,*/ C, 11),
__STM32_PIN(113, /*APB2,*/ C, 12),
__STM32_PIN(114, /*APB2,*/ D, 0),
__STM32_PIN(115, /*APB2,*/ D, 1),
__STM32_PIN(116, /*APB2,*/ D, 2),
__STM32_PIN(117, /*APB2,*/ D, 3),
__STM32_PIN(118, /*APB2,*/ D, 4),
__STM32_PIN(119, /*APB2,*/ D, 5),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(122, /*APB2,*/ D, 6),
__STM32_PIN(123, /*APB2,*/ D, 7),
__STM32_PIN(124, /*APB2,*/ G, 9),
__STM32_PIN(125, /*APB2,*/ G, 10),
__STM32_PIN(126, /*APB2,*/ G, 11),
__STM32_PIN(127, /*APB2,*/ G, 12),
__STM32_PIN(128, /*APB2,*/ G, 13),
__STM32_PIN(129, /*APB2,*/ G, 14),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
__STM32_PIN(132, /*APB2,*/ G, 15),
__STM32_PIN(133, /*APB2,*/ B, 3),
__STM32_PIN(134, /*APB2,*/ B, 4),
__STM32_PIN(135, /*APB2,*/ B, 5),
__STM32_PIN(136, /*APB2,*/ B, 6),
__STM32_PIN(137, /*APB2,*/ B, 7),
__STM32_PIN_DEFAULT,
__STM32_PIN(139, /*APB2,*/ B, 8),
__STM32_PIN(140, /*APB2,*/ B, 9),
__STM32_PIN(141, /*APB2,*/ E, 0),
__STM32_PIN(142, /*APB2,*/ E, 1),
__STM32_PIN_DEFAULT,
__STM32_PIN_DEFAULT,
#endif
};

#define ITEM_NUM(items) sizeof(items)/sizeof(items[0])
static const struct pin_index *get_pin(uint8_t pin)
{
const struct pin_index *index;

if (pin < ITEM_NUM(pins))
{
index = &pins[pin];
if (index->index == -1)
index = RT_NULL;
}
else
{
index = RT_NULL;
}

return index;
};

static void stm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
{
const struct pin_index *index;

index = get_pin(pin);
if (index == RT_NULL)
{
return;
}

if (value == PIN_LOW)
{
//GPIO_ResetBits(index->gpio, index->pin);
HAL_GPIO_WritePin(index->gpio, index->pin, GPIO_PIN_RESET);
}
else
{
//GPIO_SetBits(index->gpio, index->pin);
HAL_GPIO_WritePin(index->gpio, index->pin, GPIO_PIN_SET);
}
}

static int stm32_pin_read(rt_device_t dev, rt_base_t pin)
{
int value;
const struct pin_index *index;

value = PIN_LOW;

index = get_pin(pin);
if (index == RT_NULL)
{
return value;
}

//if (GPIO_ReadInputDataBit(index->gpio, index->pin) == Bit_RESET)
if(HAL_GPIO_ReadPin(index->gpio, index->pin) == RESET)
{
value = PIN_LOW;
}
else
{
value = PIN_HIGH;
}

return value;
}
static void RCC_APB2PeriphClockCmd(GPIO_TypeDef *gpio, FunctionalState NewState)
{
/* Check the parameters */
assert_param(gpio != RT_NULL);
assert_param(IS_FUNCTIONAL_STATE(NewState));

if (NewState != DISABLE)
{
//RCC->APB2ENR |= RCC_APB2Periph;
#if (STM32F10X_PIN_NUMBERS == 64)
if(GPIOA == gpio)
__HAL_RCC_GPIOA_CLK_ENABLE();
if(GPIOB == gpio)
__HAL_RCC_GPIOB_CLK_ENABLE();
if(GPIOC == gpio)
__HAL_RCC_GPIOC_CLK_ENABLE();
if(GPIOD == gpio)
__HAL_RCC_GPIOD_CLK_ENABLE();
#endif
#if (STM32F10X_PIN_NUMBERS == 100)
if(GPIOE == gpio)
__HAL_RCC_GPIOE_CLK_ENABLE();
#endif
#if (STM32F10X_PIN_NUMBERS == 144)
if(GPIOF == gpio)
__HAL_RCC_GPIOF_CLK_ENABLE();
if(GPIOG == gpio)
__HAL_RCC_GPIOG_CLK_ENABLE();
#endif
}
else
{
//RCC->APB2ENR &= ~RCC_APB2Periph;
#if (STM32F10X_PIN_NUMBERS == 64)
if(GPIOA == gpio)
__HAL_RCC_GPIOA_CLK_DISABLE();
else if(GPIOB == gpio)
__HAL_RCC_GPIOB_CLK_DISABLE();
else if(GPIOC == gpio)
__HAL_RCC_GPIOC_CLK_DISABLE();
else if(GPIOD == gpio)
__HAL_RCC_GPIOD_CLK_DISABLE();
#endif
#if (STM32F10X_PIN_NUMBERS == 100)
if(GPIOE == gpio)
__HAL_RCC_GPIOE_CLK_DISABLE();
#endif
#if (STM32F10X_PIN_NUMBERS == 144)
if(GPIOF == gpio)
__HAL_RCC_GPIOF_CLK_DISABLE();
if(GPIOG == gpio)
__HAL_RCC_GPIOG_CLK_DISABLE();
#endif
}
}

void stm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode)
{
const struct pin_index *index;
GPIO_InitTypeDef GPIO_InitStructure;

index = get_pin(pin);
if (index == RT_NULL)
{
return;
}

/* GPIO Periph clock enable */
RCC_APB2PeriphClockCmd(index->gpio, ENABLE);

/* Configure GPIO_InitStructure */
GPIO_InitStructure.Pin = index->pin;
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStructure.Speed = GPIO_SPEED_FREQ_LOW;

if (mode == PIN_MODE_OUTPUT)
{
/* output setting */
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
}
else if (mode == PIN_MODE_INPUT)
{
/* input setting: not pull. */
GPIO_InitStructure.Mode = GPIO_MODE_INPUT;
}
if (mode == PIN_MODE_INPUT_PULLUP)
{
/* input setting: pull up. */
//GPIO_InitStructure.Mode = GPIO_Mode_IPU;
GPIO_InitStructure.Pull = GPIO_PULLUP;
}
else
{
/* input setting:default. */
GPIO_InitStructure.Pull = GPIO_PULLDOWN;
}
HAL_GPIO_Init(index->gpio, &GPIO_InitStructure);
}

const static struct rt_pin_ops _stm32_pin_ops =
{
stm32_pin_mode,
stm32_pin_write,
stm32_pin_read,
};

int stm32_hw_pin_init(void)
{
int result;

result = rt_device_pin_register("pin", &_stm32_pin_ops, RT_NULL);
return result;
}
INIT_BOARD_EXPORT(stm32_hw_pin_init);

#endif
【4】打开drv_gpio.h文件，修改如下：
#ifndef GPIO_H__
#define GPIO_H__

#include <stdint.h>
#include <drivers/pin.h>

struct stm32_hw_pin_app
{
int pin;
uint32_t mode;
};

#define PIN_USERDATA_END {-1,0}

extern struct stm32_hw_pin_app stm32_pins[];

int stm32_hw_pin_init(void);

#endif

【5】经过上面代码修改后，打开rt-thread-2.1.0\bsp\stm32f10x-curer\drivers目录下SConscript，加入RT_USING_PIN编译选项，修改结果如下：
# add the general drivers.
src = Split("""
board.c
stm32f1xx_it.c
drv_led.c
drv_usart.c
""")

if GetDepend(['RT_USING_PIN']):
src += ['drv_gpio.c']

【6】打开rt-thread-2.1.0\bsp\stm32f10x-curer\applications目录下的application.c文件，加入pin功能的应用代码，修改如下：
static void led_thread_entry(void* parameter)
{
unsigned int count=0;

int rt_led_hw_init();
stm32_hw_pin_init();
rt_pin_mode(19, PIN_MODE_OUTPUT);

while (1)
{
/* led1 on */
#ifndef RT_USING_FINSH
rt_kprintf("led on, count : %d\r\n",count);
#endif
count++;
rt_led_on();
rt_pin_write(19, PIN_HIGH);

rt_thread_delay( RT_TICK_PER_SECOND/2 ); /* sleep 0.5 second and switch to other thread */
rt_pin_write(19, PIN_LOW);

/* led1 off */
#ifndef RT_USING_FINSH
rt_kprintf("led off\r\n");
#endif
rt_led_off();
rt_thread_delay( RT_TICK_PER_SECOND/2 );
}上面代码中pin引脚编号19对应PF7。
【7】如果没有意外，通过scons --target=mdk5 -s重新生成下工程，编译是可以通过的。

观察开发板上PF7对应的LED2灯，可以观察到指示灯在闪烁。当然也可以不再上面进程中操作pin引脚，可以在终端中通过命令来操作。进行配置和读写。