RT-Thread学习笔记【PIN设备】

最新推荐文章于 2023-09-21 19:03:44 发布
最新推荐文章于 2023-09-21 19:03:44 发布
阅读量971 收藏 3
点赞数
分类专栏： rtos 文章标签： stm32 嵌入式 rtos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40500005/article/details/113875184
版权

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种类型

上升沿触发检测无抖动的上升沿
下降沿触发检测无抖动的下降沿
高电平触发检测高电平状态
低电平触发检测低电平状态
双边沿触发检测无抖动的双边沿

  • 可编程输入输出

  • 可编程具体使用模式

输出模式对应：推挽、开漏、内部上拉、内部下拉

输入模式对应：浮空、内部上拉、内部下拉、模拟

PIN设备的使用

RTT内置了一些PIN设备API供用户使用

获取引脚编号

RTT提供的引脚编号和芯片的引脚编号不是同一个概念

RTT的引脚编号由设备驱动程序定义

使用宏函数GET_PIN或查阅PIN驱动文件可以获取到引脚编号

  1. GET_PIN()函数

通常在rt-thread/bsp/board目录中保存，需要相关的板级支持包（BSP）才能使用

部分BSP没有移植此函数

  1. 查看驱动文件

所有BSP都会移植相关PIN驱动代码，可以查看drv_gpio.c文件确认引脚编号

通常引脚编号保存在一个固定数组中，如下所示

static const struct pin_index pins[] =
{
#if (STM32F10X_PIN_NUMBERS == 36)
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(7, A, 0),
    __STM32_PIN(8, A, 1),
    __STM32_PIN(9, A, 2),
    __STM32_PIN(10, A, 3),
    __STM32_PIN(11, A, 4),
    __STM32_PIN(12, A, 5),
    __STM32_PIN(13, A, 6),
    __STM32_PIN(14, A, 7),
    __STM32_PIN(15, B, 0),
    __STM32_PIN(16, B, 1),
    __STM32_PIN(17, B, 2),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(20, A, 8),
    __STM32_PIN(21, A, 9),
    __STM32_PIN(22, A, 10),
    __STM32_PIN(23, A, 11),
    __STM32_PIN(24, A, 12),
    __STM32_PIN(25, A, 13),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(28, A, 14),
    __STM32_PIN(29, A, 15),
    __STM32_PIN(30, B, 3),
    __STM32_PIN(31, B, 4),
    __STM32_PIN(32, B, 5),
    __STM32_PIN(33, B, 6),
    __STM32_PIN(34, B, 7),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
#endif
#if (STM32F10X_PIN_NUMBERS == 48)
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(2, C, 13),
    __STM32_PIN(3, C, 14),
    __STM32_PIN(4, C, 15),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(10, A, 0),
    __STM32_PIN(11, A, 1),
    __STM32_PIN(12, A, 2),
    __STM32_PIN(13, A, 3),
    __STM32_PIN(14, A, 4),
    __STM32_PIN(15, A, 5),
    __STM32_PIN(16, A, 6),
    __STM32_PIN(17, A, 7),
    __STM32_PIN(18, B, 0),
    __STM32_PIN(19, B, 1),
    __STM32_PIN(20, B, 2),
    __STM32_PIN(21, B, 10),
    __STM32_PIN(22, B, 11),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(25, B, 12),
    __STM32_PIN(26, B, 13),
    __STM32_PIN(27, B, 14),
    __STM32_PIN(28, B, 15),
    __STM32_PIN(29, A, 8),
    __STM32_PIN(30, A, 9),
    __STM32_PIN(31, A, 10),
    __STM32_PIN(32, A, 11),
    __STM32_PIN(33, A, 12),
    __STM32_PIN(34, A, 13),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,
    __STM32_PIN(37, A, 14),
    __STM32_PIN(38, A, 15),
    __STM32_PIN(39, B, 3),
    __STM32_PIN(40, B, 4),
    __STM32_PIN(41, B, 5),
    __STM32_PIN(42, B, 6),
    __STM32_PIN(43, B, 7),
    __STM32_PIN_DEFAULT,
    __STM32_PIN(45, B, 8),
    __STM32_PIN(46, B, 9),
    __STM32_PIN_DEFAULT,
    __STM32_PIN_DEFAULT,

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

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

以STM32为例，__STM32_PIN(142, E, 1)表示142为RTT引脚编号，E为端口号（GPIOE），1代表物理引脚号

也就是说GPIOE1对应的RTT引脚编号为142

引脚设置

  1. 引脚模式设置

使用rt_pin_mode()来设置引脚输入/输出模式

void rt_pin_mode(rt_base_t pin, rt_base_t mode)
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    _hw_pin.ops->pin_mode(&_hw_pin.parent, pin, mode);
}

static struct rt_device_pin _hw_pin;//PIN设备对象
struct rt_device_pin
{
    struct rt_device parent;//继承自设备对象
    const struct rt_pin_ops *ops;
};
struct rt_pin_ops//相关属性
{
    void (*pin_mode)(struct rt_device *device, rt_base_t pin, rt_base_t mode);
    void (*pin_write)(struct rt_device *device, rt_base_t pin, rt_base_t value);
    int (*pin_read)(struct rt_device *device, rt_base_t pin);

    /* TODO: add GPIO interrupt */
    rt_err_t (*pin_attach_irq)(struct rt_device *device, rt_int32_t pin,
                      rt_uint32_t mode, void (*hdr)(void *args), void *args);
    rt_err_t (*pin_dettach_irq)(struct rt_device *device, rt_int32_t pin);
    rt_err_t (*pin_irq_enable)(struct rt_device *device, rt_base_t pin, rt_uint32_t enabled);
};

stm32f103默认可以设置的工作模式如下，其他MCU/SoC的实际支持模式需参考相关驱动程序的实现

#define PIN_MODE_OUTPUT         0x00//普通输出
#define PIN_MODE_INPUT          0x01//普通输入
#define PIN_MODE_INPUT_PULLUP   0x02//内部上拉输入
#define PIN_MODE_INPUT_PULLDOWN 0x03//内部下拉输入
#define PIN_MODE_OUTPUT_OD      0x04//开漏输出
  1. 设置引脚中断模式与绑定/脱离引脚回调函数

使用rt_pin_attach_irq()将目标引脚配置为某种中断触发模式并绑定一个中断回调函数到对应引脚，当中断发生时会执行回调函数

rt_err_t rt_pin_attach_irq(rt_int32_t pin,//引脚编号
                           rt_uint32_t mode,//中断触发模式
                           void (*hdr)(void *args),//中断回调函数，用户需自行定义
                           void  *args)//中断回调函数的参数，不需要时应设置为RT_NULL
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    if(_hw_pin.ops->pin_attach_irq)
    {
        return _hw_pin.ops->pin_attach_irq(&_hw_pin.parent, pin, mode, hdr, args);
    }
    return RT_ENOSYS;
}

可设置的中断触发模式如下

#define PIN_IRQ_MODE_RISING             0x00//上升沿触发
#define PIN_IRQ_MODE_FALLING            0x01//下降沿触发
#define PIN_IRQ_MODE_RISING_FALLING     0x02//边沿触发
#define PIN_IRQ_MODE_HIGH_LEVEL         0x03//高电平触发
#define PIN_IRQ_MODE_LOW_LEVEL          0x04//低电平触发
  1. 脱离引脚中断回调函数

使用rt_pin_dettach_irq()脱离某个引脚的中断回调函数

rt_err_t rt_pin_dettach_irq(rt_int32_t pin)
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    if(_hw_pin.ops->pin_dettach_irq)
    {
        return _hw_pin.ops->pin_dettach_irq(&_hw_pin.parent, pin);
    }
    return RT_ENOSYS;
}

注意：引脚脱离中断回调函数后，中断并未关闭，还可以绑定中断回调函数或绑定其他回调函数

引脚使用

  1. 引脚电平输出设置

使用rt_pin_write()设置当前引脚输出的电平

void rt_pin_write(rt_base_t pin, rt_base_t value)
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    _hw_pin.ops->pin_write(&_hw_pin.parent, pin, value);
}

参数如下

#define PIN_LOW                 0x00//输出低电平
#define PIN_HIGH                0x01//输出高电平
  1. 引脚电平读取设置

使用rt_pin_read()读取当前引脚模式

int  rt_pin_read(rt_base_t pin)
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    return _hw_pin.ops->pin_read(&_hw_pin.parent, pin);
}

一般使用形式为status=rt_pin_read(GPIOx_Pinx);

将读取结果保存在变量status中

  1. 使能引脚中断

使用以下API使能引脚中断

#define PIN_IRQ_DISABLE                 0x00
#define PIN_IRQ_ENABLE                  0x01

rt_err_t rt_pin_irq_enable(rt_base_t pin, rt_uint32_t enabled)
{
    RT_ASSERT(_hw_pin.ops != RT_NULL);
    if(_hw_pin.ops->pin_irq_enable)
    {
        return _hw_pin.ops->pin_irq_enable(&_hw_pin.parent, pin, enabled);
    }
    return RT_ENOSYS;
}

引脚中断设置、绑定并开启后才能启用

上述所有API与使用的设备驱动相关，实际使用时需要查阅驱动程序

内 鬼
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RT-Thread源码详解（一）-----PIN设备
renqingxin2011的博客
07-02 2886
最近抖音、朋友圈全是关于声援华为的消息。没有自家的操作系统就是要被别人限制，作为建设社会主义的接班人，在这时候总要做点什么。我作为一名一事无成的大龄青年，没有在危难之际拯救世界的能力；如果在朋友圈转发一下文章“呐喊一下”，打开手机看了一下在自己朋友圈，只有一百多人，印象里这些人都没有去过美国，又没法给美国佬捎个信，表达我心中的不满。思来想去，最近在学习一款国产的物联网操作系统RT-Thread，正...
RT-Thread学习笔记.xmind
06-02
自己做的笔记
【rtthread设备】第一篇：pin设备
weixin_43810563的博客
05-15 2689
一、pin设备概念 rtthread根据引脚编号访问硬件的引脚和设置外部中断。 二、pin设备api rtthread根据编号访问硬件的引脚，在stm32中通过宏GET_PIN(port，pin)获取引脚编号，之后可以 设置引脚模式 读写引脚 设置引脚中断回调 使/失能引脚中断 //获取pin编号 GET_PIN(port, pin) //设置引脚模式 /* pin：引脚编号 mode：模式，可取 #define PIN_MODE_OUTPUT 0x00 /* 输 出 */ #defi
rt-thread驱动构架之pin
victor_zy的博客
01-11 517
先看手册中，GPIO的寄存器映射： 至少有两点可以确定： 从GPIOA到GPIOH，地址是连续的 每组GPIO基地址相差0x400 依据这，rt-thread在给GPIO编号的时候，给每组port定义一个偏移，偏移单位是0x400 port 偏移几个单位 GPIOA 0 GPIOB 1 GPIOC 2 … … 比如，知道了GPIO的基地址是0x48000000，那么GPIOB的基地址是 0x48000000 + 0x400 * 1 rt-thread中给GPIO的编号
RT-Thread记录（十三、I/O 设备模型之PIN设备）
不浮夸，不将就，认真对待学知识的我们
05-29 1323
从原理到使用一文详细了解 RT-Thread 的PIN设备模型
【RT-Thread】PIN 设备源码分析
chingax_csdn
05-08 798
目录1 获取引脚编号2 设置引脚模式 关于 RT-Thread 的 PIN 设备驱动应用层面的介绍可以直接参考 RT-Thread 的官网：PIN 设备 下面结合相关源代码分析一下 PIN 设备驱动。 1 获取引脚编号 首先拿到标准的 BSP 后，main.c 里面会有一个 IO 口的操作，内容如下： /* defined the LED0 pin: PB1 */ #define LED0_PIN 24 //GET_PIN(B, 8) int main(void) { int count =
[攻城狮计划]|RT-Thread—详解PIN设备(基于RA2E1)
weixin_66578482的博客
03-30 1177
🚀🚀开启攻城狮的成长之旅！这是我参与的由 CSDN博客专家 架构师李肯和 瑞萨MCU 联合发起的「 致敬未来的攻城狮计划 」的第2天，点击查看活动[攻城狮计划]|RT-Thread—详解PIN设备(基于RA2E1) PIN简介 🚗输入输出模式 输出 输入 🚗中断模式 PIN 设备管理 创建和注册PIN设备 🚗创建 🚗注册 访问PIN设备 🚗获取引脚编号 使用 API 🚗设置引脚模式 🚗设置引脚电平 🚗读取引脚电平 🚗绑定引脚中断回调函数 🚗使能引脚中断 🚗脱离引脚中断回调函数 代码
RT-Thread学习笔记总结.tar.gz
07-08
本学习笔记总结将全面介绍RT-Thread的核心概念、功能特性、开发环境搭建以及实际应用案例，帮助初学者快速入门。 一、RT-Thread核心概念 1. 线程：RT-Thread中的线程相当于操作系统的任务，负责执行特定的功能。...
rt-thread mcp2515驱动程序参考
最新发布
11-01
RT-Thread MCP2515驱动程序是专为在嵌入式系统中实现SPI到CAN（Controller Area Network）转换而设计的。MCP2515是一款由Microchip Technology公司生产的CAN控制器，它通过SPI（Serial Peripheral Interface）接口与...
RT-Thread API参考手册.pdf
12-20
此外，RT-Thread还支持多种设备驱动、网络协议栈、图形用户界面（GUI）、智能语音交互等高级功能，使得开发者能够构建复杂、功能丰富的物联网应用。丰富的软件包生态系统是RT-Thread的一大亮点，开发者可以方便地...
RT-Thread PIN设备驱动框架
07-13
RT-Thread PIN设备驱动框架
RT_Thread_PIN读写
人非生而知之者
04-11 2034
官方资料：PIN设备 (rt-thread.org) 1、代码 下面代码是宏定义引脚，然后操作引脚输出高低电平，并读取引脚电平； （P.S.引脚是输出模式，也可以读取引脚电平的） //宏定义LED的引脚编号PF9 #define LED0_PIN GET_PIN(F, 9) int main(void) { //设置LED为推挽输出 rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT); while (1) { rt_p
老李的RT-THREAD学习01--点灯
深圳五月花--老李的森林
01-27 827
RT-THREAD学习01 一灯大师（点灯篇）硬件环境软件环境新建工程点灯踩坑完整代码如下 硬件环境 自制的F767IGT6开发板，板载USB，UART1，CAN1，LED，按键等资源，SWD调试接口，其他引脚全部用插针引出 软件环境 RT-THread 4.0.2，开发环境为RT-Thread Studio 2.0.0 自制ST-Link-V2.1，CubeMX，Keil MDK，串口助手（哪个都可以用，建议用Putty，方便调试）等 新建工程 通过基于芯片的方式新建工程， 需要注意的是，此时新建的工
【STM32&RT-Thread零基础入门】 3. PIN设备（GPIO）的使用
weixin_43002939的博客
08-11 2752
在嵌入式系统中，GPIO是最常用的一种设备，在RT-Thread操作系统中，把GPIO命名为PIN设备。RT-Thread通过PIN设备对芯片的GPIO引脚进行管理，应用程序可以通过其提供的一组PIN设备管理接口来操作GPIO，PIN设备管理接口如表所示接口描述获取引脚编号设置引脚模式设置引脚电平读取引脚电平绑定引脚中断回调函数使能引脚中断脱离引脚中断回调函数从任务4测试结果中，我们可以发现，按键功能影响了闪灯的功能，说明两个功能还是没有很好地解耦，依然存在相互影响的情况。
rtthread芯片管脚号计算
weixin_42306014的博客
09-21 252
为帮助您在CSDN创作的文章获得更多曝光和关注，我们为您提供了专属福利： 已注册且未在CSDN平台发布过文章的用户，9月1日—9月30日期间发布首篇文章可享大额首篇流量券扶持，且发布首篇文章后30日内，享连续每日流量券扶持； 已注册且未在CSDN平台发布过文章的用户，在8月1日—8月30日期间发布过首篇，可自9月1日起，享连续30天每日流量券扶持；更多福利介绍详见https://mp.csdn.net/mp_blog/manage/traffic如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇
RT-Thread初识学习-04-GPIO操作
m0_55093622的博客
02-25 3370
RT_Thread的GPIO操作
RT-Thread 基于STM32F1xx HAL 库的学习笔记(2)---加入pin功能支持
aping_cs_dn的专栏
12-02 1396
RT-Thread的pin功能是个有意思的功能，在系统注册成misc之后，可以在进程中对芯片的IO引脚进行配置和读写。 虽然在components\drivers\misc目录下pin.c中实现了中间的驱动，但是没底层驱动是难以发挥其功能的，这里就学习下如何通过底层驱动来实现在进程中进行pin操作。 在rt-thread-2.1.0\bsp\stm32f40x\drivers目录中有基于stm
RTT常见操作——GPIO
mengqingbin5219的博客
11-05 1565
注意需要在对应.c中添加 #include <rtdevice.h> #include <board.h> 这两个头文件。 1.获取引脚编号 GET_PIN(port, pin) 获取引脚号为 PF9 的 LED0 对应的引脚编号的示例代码如下所示： #define LED0_PIN GET_PIN(F, 9) 2.设置引脚模式 void rt_pin_mode(rt_base_t pin, rt_base_t mode); mode： #define PIN_
RT-Thread Pin 设备驱动框架快速对接
Murphy
07-10 1807
为什么需要 Pin 设备驱动框架 跨平台可移植应用 操作简单 试想下面这个场景： 你基于 STM32 MCU 编写了一个包含很多 GPIO 操作的应用程序，GPIO 控制函数使用的是 HAL 库。 后面，由于某种原因，MCU 需要更换，使用的是 NXP 的芯片，不支持 HAL 库，那你怎么办？ 通常，你会查找所有 GPIO 操作相关的接口，然后替换成 NXP 提供的 GPIO 驱动函数，如果 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值