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

最新推荐文章于 2023-12-05 19:10:40 发布
最新推荐文章于 2023-12-05 19:10:40 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： ArmflySTM32F103ZEV3开发板 嵌入式开发环境
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aping_cs_dn/article/details/53438526
版权

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引脚，可以在终端中通过命令来操作。进行配置和读写。




aping_cs_dn
关注
专栏目录
STM32F1xx_HAL_Driver
10-29
STM32L1xx HAL驱动程序的发行说明 如果满足以下条件，则允许以源代码和二进制形式重新分发和使用，无论是否经过修改： 源代码的重新分发必须保留上述版权声明，此条件列表和以下免责声明。 二进制形式的再分发必须在随分发提供的文档和/或其他材料中复制上述版权声明，此条件列表和以下免责声明。 STMicroelectronics的名称或其贡献者的名称均不得用于支持或推广衍生产品 未经事先书面许可，不得使用此软件。
STM32F1xx_HAL_Driver.rar
11-29
在Keil MDK 5里面直接创建使用HAL库的STM32工程,不使用STM32CubeMX，适用于STM32F1XX系列，需要自行添加mcu头文件。已经将STM32F107放进去了
RT-Thread 驱动 PIN 设备
程序员「阿基米东」的编程之旅
07-11 4644
本示例在 STM32 NUCLEO-F411RE 开发板进行，由于 RT-Thread 项目中已包含对应的 BSP，也就是 bsp/stm32/stm32f411-st-nucleo 工程目录，因此我们在此基础上进行开发即可。 用 RT-Thread 控制 STM32 的 GPIO 有两种方法： 使用 HAL 库的函数 使用 RT-Thread 的 pin 设备 本示例使用 RT-Thread...
2.1 rtthread pin设备详解
rou252051452的博客
06-25 2248
RTT下STM32的PIN设备实现详解
RT-Thread设备框架之pin源码分析
jdhfusk的博客
02-21 1788
RT-Thread设备框架之pin源码分析 有关 pin 设备的共有4个文件，分别是pin.c、pin.h、drv_gpio.c、drv_gpio.h。 ​ 其中pin.c、pin.h是上层文件，为用户提供可以直接调用的API。而drv_gpio.c、drv_gpio.h是底层的驱动文件，实现对接HAL库的功能（或者其他芯片厂商的SDK），是真正“干活”的那一个。 ​ 这样做的好处就是上层能对各平台驱动实现抽象，调用一套接口就能操作不同平台的硬件，代码复用性和可移植性得到了大大的提升。既然drv_g
RT-Thread+stm32f10x-HAL 使用ADC设备程序
08-11
嵌入式操作系统RT-Thread的ADC设备使用示例（使用的bsp为rt-thread-v4.0.1版本的stm32f10x-HAL）。 注：rt-thread-v4.0.1\bsp\stm32\stm32f103-fire-arbitrary 可以通过env工具运行menuconfig直接使用ADC设备，使用...
基于Rust语言的stm32f1xx-hal库设计源码分享与开发心得
09-30
该项目为基于Rust语言的stm32f1xx-hal库设计的源码分享，涉及105个文件，包括81个Rust源文件、4个YAML配置文件、3个Markdown文档、2个TOML文件、2个XML文件，以及其他必要的配置和工具文件。该项目专注于STM32微控制...
基于Rust语言的stm32f1xx-hal设计源码
最新发布
10-01
该项目为基于Rust语言的stm32f1xx-hal设计源码，包含105个文件，涵盖81个Rust源文件、4个YAML配置文件、4个禁用文件、3个Markdown文件、2个TOML文件、2个X文件、1个Cargo配置文件、1个gdb初始化文件、1个git属性文件...
毕设&课程作业_STM32的rt-thread pin驱动生成器 基于HAL库.zip
03-11
本项目“毕设&课程作业_STM32的rt-thread pin驱动生成器 基于HAL库.zip”主要针对STM32的实时操作系统rt-thread进行开发，目的是生成针对GPIO（通用输入/输出）的驱动代码，这在硬件控制和系统交互中至关重要。...
stm32f103标准库+rt-thread 3.1.3+finsh
11-02
STM32F103是意法半导体（STMicroelectronics）推出的一款基于ARM Cortex-M3内核的微控制器，属于STM32F1系列。它具有高性能、低功耗的特点，广泛应用于各种嵌入式系统设计。在本项目中，开发者使用了STM32F103的标准...
基于RT-Thread-nano的STM32 PIN设备移植
xieyuesandian的博客
07-03 931
基于RT-Thread-nano的STM32 PIN设备移植
RT Thread device（二） PIN 与移植
denghuajing的博客
03-28 3868
RT Thread PIN 部署上主要有 application 应用层，开发者自己创建的C文件或者模块 RTT IO Device 是RTT PIN接口，对于所有的应用程序来说，使用这个相同的接口。 RT HAL HAL interface 用于MCU 和RTT特定的 PIN接口之间的解耦 最后由MCU 官方HAL库实现PIN 组件的物理操作 application 应用程序 产生对PIN 读写操作的需求，其输入参数为RTT PIN INDEX ，特别的命名方式对开发者比较友好。它可以提供RTT PIN
RT-Thread学习笔记【PIN设备】
qq_40500005的博客
02-20 1031
PIN设备 MCU/SoC上的引脚可以分为四类：电源（PWR、VCC、VDD、VSS、GND等）、时钟（CCLK、CLK、SLK等）、控制（EN、NSS、PRI等）、IO（GPIOx、I/Ox、Px、URx、UTx、SPIx、IICx等） 不同于一般MCU裸机编程中的GPIO复用（AF）设置，RTT将MCU的GPIO抽象为通用引脚PIN设备 在RTT系统中可以编程以下设置 可编程中断 共5种类型 上升沿触发 检测无抖动的上升沿 下降沿触发 检测无抖动的下降沿 高电平触发 检测高电平状
RT-Thread系列03——PIN设备及外部中断
32Haozi
12-08 1138
RT-Thread使用PIN引脚及中断控制LED。
RT-Thread学习笔记(1)：pin设备框架的简单解读
BLBQ962464的博客
03-10 1417
重要结构体介绍 rt_device_pin结构体 struct rt_device_pin { struct rt_device parent; /* 父类 */ const struct rt_pin_ops *ops; /* 操作函数集 */ }; rt_device结构体 struct rt_device { struct rt_object parent; /**< inherit from rt_objec
＜＜RT_Thread gd450 学习 ＞＞ 二. drv_gpio
m0_47226014的博客
07-22 609
GD450z 开发板 drv_gpio驱动 修改SConscript 解决默认工程添加文件后保存配置消失问题， drv_gpio 使用流水灯demo
STM32F10X系列的引脚配置问题
LS的博客
06-17 2891
一、引脚配置是否设置速度的问题二、速度设置多大的问题三、引脚配置过程中的注意事项（误区）一、引脚配置是否设置速度的问题查看数据手册可以知道STM32的引脚速度配置并不是独立是，他是与输出绑定的推理过程：①引脚配置为通用输出时，一定要配置速度（经测试：不配置速度，则引脚被错误的配置成了模拟或者浮空输入，输出操作时无效）②引脚配置为复用输出时：一定要配置速度（不配置速度，则引脚被错误的配置成上拉或者下...
RT-Thread 学习笔记（十二）--- 开启基于RTGUI的LCD显示功能(2)<编译测试>
aping_cs_dn的专栏
04-11 7690
软件环境：Win7，Keil MDK 4.72a, IAR EWARM 7.2, GCC 4.2，Python 2.7 ,SCons 2.3.2 硬件环境：Armfly STM32F103ZE-EK v3.0开发板 参考文章：RT-Thread编程指南 RT-Thread_1.2.0+lwip+rtgui0.8.0 移植心得 RT-Thread RTOS组件：RTGUI
RT-Thread STM32F429 armfly-v6开发板BSP说明
华为奋斗者精神
12-05 1044
本文档为 RT-Thread 开发团队为 STM32F429 armfly-v6 开发板提供的 BSP (板级支持包) 说明。开发板资源介绍BSP 快速上手进阶使用方法通过阅读快速上手章节开发者可以快速地上手该 BSP，将 RT-Thread 运行在开发板上。在进阶使用指南章节，将会介绍更多高级功能，帮助开发者利用 RT-Thread 驱动更多板载资源。
stm32l151 rt-thread移植所需文件与库依赖详解
2. cpu相关支持：在rt-thread-3.1.3的lib/cpu/arm/cortex-m3子目录下，有context_gcc.S和cpuport.c文件，它们是针对Cortex-M3处理器的初始化和硬件抽象层，移植时需要根据STM32L151的具体特性进行适当调整。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

aping_cs_dn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值