clion开发之threadx+gd32f4xx驱动(gpio驱动)

最新推荐文章于 2024-08-18 18:20:59 发布
最新推荐文章于 2024-08-18 18:20:59 发布
阅读量243 收藏 4
点赞数 9
分类专栏： GD32 文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742767/article/details/141302307
版权

前言

  1. 本次使用的os为threadx,版本为6.4
  2. 芯片使用的是gd32f425，开发库为GD官方提供的标准库
  3. 开发环境使用的使用clion
  4. 参考驱动程序为rt-thread的pin组件和相关驱动所编写

GPIO 驱动

IO口宏定义(便于快速定义，不用去底层进行找对应关系)

/**
  ******************************************************************************
  * @file           : bsp_gpio_def.h
  * @author         : SCL
  * @brief          : None
  * @attention      : None
  * @date           : 24-7-31
  ******************************************************************************
  * Change Logs:
  * Date           Author       Notes
  * 24-7-31        SCL      first version
  */


#ifndef BSP_GPIO_DEF_H
#define BSP_GPIO_DEF_H
#define PA0 0
#define PA1 1
#define PA2 2
#define PA3 3
#define PA4 4
#define PA5 5
#define PA6 6
#define PA7 7
#define PA8 8
#define PA9 9
#define PA10 10
#define PA11 11
#define PA12 12
#define PA13 13
#define PA14 14
#define PA15 15
#define PB0  16
#define PB1  17
#define PB2  18
#define PB3  19
#define PB4  20
#define PB5  21
#define PB6  22
#define PB7  23
#define PB8  24
#define PB9  25
#define PB10 26
#define PB11 27
#define PB12 28
#define PB13 29
#define PB14 30
#define PB15 31
#define PC0  32
#define PC1  33
#define PC2  34
#define PC3  35
#define PC4  36
#define PC5  37
#define PC6  38
#define PC7  39
#define PC8  40
#define PC9  41
#define PC10 42
#define PC11 43
#define PC12 44
#define PC13 45
#define PC14 46
#define PC15 47
#define PD0  48
#define PD1  49
#define PD2  50
#define PD3  51
#define PD4  52
#define PD5  53
#define PD6  54
#define PD7  55
#define PD8  56
#define PD9  57
#define PD10 58
#define PD11 59
#define PD12 60
#define PD13 61
#define PD14 62
#define PD15 63
#define PE0  64
#define PE1  65
#define PE2  66
#define PE3  67
#define PE4  68
#define PE5  69
#define PE6  70
#define PE7  71
#define PE8  72
#define PE9  73
#define PE10 74
#define PE11 75
#define PE12 76
#define PE13 77
#define PE14 78
#define PE15 79
#define PF0  80
#define PF1  81
#define PF2  82
#define PF3  83
#define PF4  84
#define PF5  85
#define PF6  86
#define PF7  87
#define PF8  88
#define PF9  89
#define PF10 90
#define PF11 91
#define PF12 92
#define PF13 93
#define PF14 94
#define PF15 95
#endif //BSP_GPIO_DEF_H

gpio驱动

/*
 * Copyright (c) 2024-2024,shchl
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 24-8-18     shchl   first version
 */

#ifndef TX_GD32F425_DRV_GPIO_H
#define TX_GD32F425_DRV_GPIO_H
#include "bsp_gpio_def.h"
#define GD32_PIN(index, port, pin) {index, RCU_GPIO##port,      \
                                    GPIO##port, GPIO_PIN_##pin, \
                                    EXTI_SOURCE_GPIO##port,     \
                                    EXTI_SOURCE_PIN##pin}
#define PIN_NONE                (-1)

enum pin_mode_enum
{
    PIN_MODE_OUTPUT,
    PIN_MODE_INPUT,
    PIN_MODE_INPUT_PULLUP,
    PIN_MODE_INPUT_PULLDOWN,
    PIN_MODE_OUTPUT_OD,
    PIN_MODE_ANALOG,
};


enum pin_value_enum
{
    PIN_LOW,
    PIN_HIGH,
};

enum pin_irq_enable_enum
{
    PIN_IRQ_DISABLE,
    PIN_IRQ_ENABLE,
};

enum pin_irq_mode_enum
{
    PIN_IRQ_MODE_RISING,
    PIN_IRQ_MODE_FALLING,
    PIN_IRQ_MODE_RISING_FALLING,
    PIN_IRQ_MODE_HIGH_LEVEL,
    PIN_IRQ_MODE_LOW_LEVEL,
};


struct pin_index
{
    int16_t index;
    rcu_periph_enum clk;
    uint32_t gpio_periph;
    uint32_t pin;
    uint8_t port_src;
    uint8_t pin_src;
};

struct pin_irq_map
{
    uint16_t pinbit;
    IRQn_Type irqno;
};

struct pin_irq_hdr
{
    uint32_t pin;
    uint8_t mode; /* e.g. PIN_IRQ_MODE_RISING */
    void (*hdr)(void* args);
    void* args;
};

void gpio_toggle(uint32_t pin);
void gpio_mode(uint32_t pin, enum pin_mode_enum mode);
void gpio_write(uint32_t pin, enum pin_value_enum value);
enum pin_value_enum gpio_read(uint32_t pin);
int8_t gpio_attach_irq(uint32_t pin, enum pin_irq_mode_enum mode, void (*hdr)(void* args), void* args);
int8_t gpio_detach_irq(uint32_t pin);
int8_t gpio_irq_enable(uint32_t pin, enum pin_irq_enable_enum enabled);

void gpio_clk_enable(uint32_t pin);
void bsp_gpio_af_set(uint32_t pin, uint32_t alt_func_num);
#endif //TX_GD32F425_DRV_GPIO_H

gpio源文件

/**
  ******************************************************************************
  * @file           : bsp_gpio.c
  * @author         : SCL
  * @brief          : None
  * @attention      : None
  * @date           : 24-7-31
  ******************************************************************************
  * Change Logs:
  * Date           Author       Notes
  * 24-7-31        SCL      first version
  */

#include "board.h"
#include "drv_gpio.h"

static const struct pin_index pins[] =
        {
#ifdef GPIOA
                GD32_PIN(0, A, 0),
                GD32_PIN(1, A, 1),
                GD32_PIN(2, A, 2),
                GD32_PIN(3, A, 3),
                GD32_PIN(4, A, 4),
                GD32_PIN(5, A, 5),
                GD32_PIN(6, A, 6),
                GD32_PIN(7, A, 7),
                GD32_PIN(8, A, 8),
                GD32_PIN(9, A, 9),
                GD32_PIN(10, A, 10),
                GD32_PIN(11, A, 11),
                GD32_PIN(12, A, 12),
                GD32_PIN(13, A, 13),
                GD32_PIN(14, A, 14),
                GD32_PIN(15, A, 15),
#endif
#ifdef GPIOB
                GD32_PIN(16, B, 0),
                GD32_PIN(17, B, 1),
                GD32_PIN(18, B, 2),
                GD32_PIN(19, B, 3),
                GD32_PIN(20, B, 4),
                GD32_PIN(21, B, 5),
                GD32_PIN(22, B, 6),
                GD32_PIN(23, B, 7),
                GD32_PIN(24, B, 8),
                GD32_PIN(25, B, 9),
                GD32_PIN(26, B, 10),
                GD32_PIN(27, B, 11),
                GD32_PIN(28, B, 12),
                GD32_PIN(29, B, 13),
                GD32_PIN(30, B, 14),
                GD32_PIN(31, B, 15),
#endif
#ifdef GPIOC
                GD32_PIN(32, C, 0),
                GD32_PIN(33, C, 1),
                GD32_PIN(34, C, 2),
                GD32_PIN(35, C, 3),
                GD32_PIN(36, C, 4),
                GD32_PIN(37, C, 5),
                GD32_PIN(38, C, 6),
                GD32_PIN(39, C, 7),
                GD32_PIN(40, C, 8),
                GD32_PIN(41, C, 9),
                GD32_PIN(42, C, 10),
                GD32_PIN(43, C, 11),
                GD32_PIN(44, C, 12),
                GD32_PIN(45, C, 13),
                GD32_PIN(46, C, 14),
                GD32_PIN(47, C, 15),
#endif
#ifdef GPIOD
                GD32_PIN(48, D, 0),
                GD32_PIN(49, D, 1),
                GD32_PIN(50, D, 2),
                GD32_PIN(51, D, 3),
                GD32_PIN(52, D, 4),
                GD32_PIN(53, D, 5),
                GD32_PIN(54, D, 6),
                GD32_PIN(55, D, 7),
                GD32_PIN(56, D, 8),
                GD32_PIN(57, D, 9),
                GD32_PIN(58, D, 10),
                GD32_PIN(59, D, 11),
                GD32_PIN(60, D, 12),
                GD32_PIN(61, D, 13),
                GD32_PIN(62, D, 14),
                GD32_PIN(63, D, 15),
#endif
#ifdef GPIOE
                GD32_PIN(64, E, 0),
                GD32_PIN(65, E, 1),
                GD32_PIN(66, E, 2),
                GD32_PIN(67, E, 3),
                GD32_PIN(68, E, 4),
                GD32_PIN(69, E, 5),
                GD32_PIN(70, E, 6),
                GD32_PIN(71, E, 7),
                GD32_PIN(72, E, 8),
                GD32_PIN(73, E, 9),
                GD32_PIN(74, E, 10),
                GD32_PIN(75, E, 11),
                GD32_PIN(76, E, 12),
                GD32_PIN(77, E, 13),
                GD32_PIN(78, E, 14),
                GD32_PIN(79, E, 15),
#endif
#ifdef GPIOF
                GD32_PIN(80, F, 0),
                GD32_PIN(81, F, 1),
                GD32_PIN(82, F, 2),
                GD32_PIN(83, F, 3),
                GD32_PIN(84, F, 4),
                GD32_PIN(85, F, 5),
                GD32_PIN(86, F, 6),
                GD32_PIN(87, F, 7),
                GD32_PIN(88, F, 8),
                GD32_PIN(89, F, 9),
                GD32_PIN(90, F, 10),
                GD32_PIN(91, F, 11),
                GD32_PIN(92, F, 12),
                GD32_PIN(93, F, 13),
                GD32_PIN(94, F, 14),
                GD32_PIN(95, F, 15),
#endif
#ifdef GPIOG
                GD32_PIN(96, G, 0),
                GD32_PIN(97, G, 1),
                GD32_PIN(98, G, 2),
                GD32_PIN(99, G, 3),
                GD32_PIN(100, G, 4),
                GD32_PIN(101, G, 5),
                GD32_PIN(102, G, 6),
                GD32_PIN(103, G, 7),
                GD32_PIN(104, G, 8),
                GD32_PIN(105, G, 9),
                GD32_PIN(106, G, 10),
                GD32_PIN(107, G, 11),
                GD32_PIN(108, G, 12),
                GD32_PIN(109, G, 13),
                GD32_PIN(110, G, 14),
                GD32_PIN(111, G, 15),
#endif
#ifdef GPIOH
                GD32_PIN(112, H, 0),
                GD32_PIN(113, H, 1),
                GD32_PIN(114, H, 2),
                GD32_PIN(115, H, 3),
                GD32_PIN(116, H, 4),
                GD32_PIN(117, H, 5),
                GD32_PIN(118, H, 6),
                GD32_PIN(119, H, 7),
                GD32_PIN(120, H, 8),
                GD32_PIN(121, H, 9),
                GD32_PIN(122, H, 10),
                GD32_PIN(123, H, 11),
                GD32_PIN(124, H, 12),
                GD32_PIN(125, H, 13),
                GD32_PIN(126, H, 14),
                GD32_PIN(127, H, 15),
#endif
#ifdef GPIOI
                GD32_PIN(128, I, 0),
                GD32_PIN(129, I, 1),
                GD32_PIN(130, I, 2),
                GD32_PIN(131, I, 3),
                GD32_PIN(132, I, 4),
                GD32_PIN(133, I, 5),
                GD32_PIN(134, I, 6),
                GD32_PIN(135, I, 7),
                GD32_PIN(136, I, 8),
                GD32_PIN(137, I, 9),
                GD32_PIN(138, I, 10),
                GD32_PIN(139, I, 11),
                GD32_PIN(140, I, 12),
                GD32_PIN(141, I, 13),
                GD32_PIN(142, I, 14),
                GD32_PIN(143, I, 15),
#endif
        };
static const struct pin_irq_map pin_irq_map[] =
        {
                {GPIO_PIN_0,  EXTI0_IRQn},
                {GPIO_PIN_1,  EXTI1_IRQn},
                {GPIO_PIN_2,  EXTI2_IRQn},
                {GPIO_PIN_3,  EXTI3_IRQn},
                {GPIO_PIN_4,  EXTI4_IRQn},
                {GPIO_PIN_5,  EXTI5_9_IRQn},
                {GPIO_PIN_6,  EXTI5_9_IRQn},
                {GPIO_PIN_7,  EXTI5_9_IRQn},
                {GPIO_PIN_8,  EXTI5_9_IRQn},
                {GPIO_PIN_9,  EXTI5_9_IRQn},
                {GPIO_PIN_10, EXTI10_15_IRQn},
                {GPIO_PIN_11, EXTI10_15_IRQn},
                {GPIO_PIN_12, EXTI10_15_IRQn},
                {GPIO_PIN_13, EXTI10_15_IRQn},
                {GPIO_PIN_14, EXTI10_15_IRQn},
                {GPIO_PIN_15, EXTI10_15_IRQn},
        };
struct pin_irq_hdr pin_irq_hdr_tab[] =
        {
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
                {-1, 0, NULL, NULL},
        };
#define ITEM_NUM(items) sizeof(items) / sizeof(items[0])

/**
  * @brief  bit2bitno
  * @param  bit
  * @retval None
  */
static inline int32_t bit2bitno(uint32_t bit) {
    for (uint8_t i = 0; i < 32; i++) {
        if ((0x01 << i) == bit) {
            return i;
        }
    }
    return -1;
}

/**
  * @brief  pin write
  * @param  pinbit
  * @retval None
  */
static inline const struct pin_irq_map *get_pin_irq_map(uint32_t pinbit) {
    int32_t map_index = bit2bitno(pinbit);
    if (map_index < 0 || map_index >= ITEM_NUM(pin_irq_map)) {
        return NULL;
    }
    return &pin_irq_map[map_index];
}

/**
  * @brief  get pin
  * @param  pin
  * @retval None
  */
const struct pin_index *get_pin(uint32_t pin) {
    const struct pin_index *index;
    if (pin < ITEM_NUM(pins)) {
        index = &pins[pin];
        if (index->index == -1)
            index = NULL;
    } else {
        index = NULL;
    }
    return index;
}

void gpio_mode(uint32_t pin, enum pin_mode_enum mode) {
    const struct pin_index *index = NULL;
    uint32_t pin_mode = 0;
    uint32_t pin_pupd = 0, pin_odpp = 0;
    index = get_pin(pin);
    if (index == NULL) {
        return;
    }
    /* GPIO Periph clock enable */
    rcu_periph_clock_enable(index->clk);
    pin_mode = GPIO_MODE_OUTPUT;
    switch (mode) {
        case PIN_MODE_OUTPUT:
            /* output setting */
            pin_mode = GPIO_MODE_OUTPUT;
            pin_pupd = GPIO_PUPD_NONE;
            pin_odpp = GPIO_OTYPE_PP;

            break;
        case PIN_MODE_OUTPUT_OD:
            /* output setting: od. */
            pin_mode = GPIO_MODE_OUTPUT;
            pin_pupd = GPIO_PUPD_NONE;
            pin_odpp = GPIO_OTYPE_OD;
            break;
        case PIN_MODE_INPUT:
            /* input setting: not pull. */
            pin_mode = GPIO_MODE_INPUT;
            pin_pupd = GPIO_PUPD_PULLUP | GPIO_PUPD_PULLDOWN;
            break;
        case PIN_MODE_INPUT_PULLUP:
            /* input setting: pull up. */
            pin_mode = GPIO_MODE_INPUT;
            pin_pupd = GPIO_PUPD_PULLUP;

            break;
        case PIN_MODE_INPUT_PULLDOWN:
            /* input setting: pull down. */
            pin_mode = GPIO_MODE_INPUT;
            pin_pupd = GPIO_PUPD_PULLDOWN;

            break;

        case PIN_MODE_ANALOG:
            /* analog setting: not pull. */
            pin_mode = GPIO_MODE_ANALOG;
            pin_pupd = GPIO_PUPD_NONE;
        default:
            break;
    }
    gpio_mode_set(index->gpio_periph, pin_mode, pin_pupd, index->pin);
    if (pin_mode == GPIO_MODE_OUTPUT) {
        gpio_output_options_set(index->gpio_periph, pin_odpp, GPIO_OSPEED_50MHZ, index->pin);
    }
}


void gpio_write(uint32_t pin, enum pin_value_enum value) {
    const struct pin_index *index = NULL;

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


    gpio_bit_write(index->gpio_periph, index->pin, value == PIN_HIGH ? SET : RESET);
}

enum pin_value_enum gpio_read(uint32_t pin) {
    int value = PIN_LOW;
    const struct pin_index *index = NULL;

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

    value = gpio_input_bit_get(index->gpio_periph, index->pin);
    return value == SET ? PIN_HIGH : PIN_LOW;
}


int8_t gpio_attach_irq(uint32_t pin, enum pin_irq_mode_enum mode, void (*hdr)(void *args), void *args) {
    const struct pin_index *index = NULL;
    BSP_DEF_CRITICAL_SECTION;
    int32_t hdr_index = -1;

    index = get_pin(pin);
    if (index == NULL) {
        return -1;
    }

    hdr_index = bit2bitno(index->pin);
    if (hdr_index < 0 || hdr_index >= ITEM_NUM(pin_irq_map)) {
        return -1;
    }
    BSP_ENTER_CRITICAL;
    if (pin_irq_hdr_tab[hdr_index].pin == pin &&
        pin_irq_hdr_tab[hdr_index].hdr == hdr &&
        pin_irq_hdr_tab[hdr_index].mode == mode &&
        pin_irq_hdr_tab[hdr_index].args == args) {
        BSP_EXIT_CRITICAL;
        return 0;
    }
    if (pin_irq_hdr_tab[hdr_index].pin != -1) {
        BSP_EXIT_CRITICAL;
        return -1;
    }
    pin_irq_hdr_tab[hdr_index].pin = pin;
    pin_irq_hdr_tab[hdr_index].hdr = hdr;
    pin_irq_hdr_tab[hdr_index].mode = mode;
    pin_irq_hdr_tab[hdr_index].args = args;
    BSP_EXIT_CRITICAL;
    return 0;
}

int8_t gpio_detach_irq(uint32_t pin) {
    const struct pin_index *index = NULL;
    int32_t hdr_index = -1;
    BSP_DEF_CRITICAL_SECTION
            index = get_pin(pin);
    if (index == NULL) {
        return -1;
    }

    hdr_index = bit2bitno(index->pin);
    if (hdr_index < 0 || hdr_index >= ITEM_NUM(pin_irq_map)) {
        return -1;
    }

    BSP_ENTER_CRITICAL;
    if (pin_irq_hdr_tab[hdr_index].pin == -1) {
        BSP_EXIT_CRITICAL;
        return 0;
    }
    pin_irq_hdr_tab[hdr_index].pin = -1;
    pin_irq_hdr_tab[hdr_index].hdr = NULL;
    pin_irq_hdr_tab[hdr_index].mode = 0;
    pin_irq_hdr_tab[hdr_index].args = NULL;
    BSP_EXIT_CRITICAL;

    return 0;
}


int8_t gpio_irq_enable(uint32_t pin, enum pin_irq_enable_enum enabled) {
    const struct pin_irq_map *irqmap;
    int32_t hdr_index = -1;
    exti_trig_type_enum trigger_mode;
    BSP_DEF_CRITICAL_SECTION;

    const struct pin_index *index = get_pin(pin);
    if (index == NULL) {
        return -1;
    }

    if (enabled == PIN_IRQ_ENABLE) {
        hdr_index = bit2bitno(index->pin);
        if (hdr_index < 0 || hdr_index >= ITEM_NUM(pin_irq_map)) {
            return -1;
        }

        BSP_ENTER_CRITICAL;
        if (pin_irq_hdr_tab[hdr_index].pin == -1) {
            BSP_EXIT_CRITICAL;
            return -1;
        }

        irqmap = &pin_irq_map[hdr_index];

        switch (pin_irq_hdr_tab[hdr_index].mode) {
            case PIN_IRQ_MODE_RISING:
                trigger_mode = EXTI_TRIG_RISING;
                break;
            case PIN_IRQ_MODE_FALLING:
                trigger_mode = EXTI_TRIG_FALLING;
                break;
            case PIN_IRQ_MODE_RISING_FALLING:
                trigger_mode = EXTI_TRIG_BOTH;
                break;
            default:
                BSP_EXIT_CRITICAL;
                return -1;
        }
        rcu_periph_clock_enable(RCU_SYSCFG);
        /* enable and set interrupt priority */
        nvic_irq_enable(irqmap->irqno, 5U, 0U);
        /* connect EXTI line to  GPIO pin */
        syscfg_exti_line_config(index->port_src, index->pin_src);
        /* configure EXTI line */
        exti_init((exti_line_enum) (index->pin), EXTI_INTERRUPT, trigger_mode);
        exti_interrupt_flag_clear((exti_line_enum) (index->pin));
        BSP_EXIT_CRITICAL;
    } else if (enabled == PIN_IRQ_DISABLE) {
        irqmap = get_pin_irq_map(index->pin);
        if (irqmap == NULL) {
            return -1;
        }
        nvic_irq_disable(irqmap->irqno);
    } else {
        return -1;
    }

    return 0;
}

void gpio_toggle(uint32_t pin) {
    const struct pin_index *index = get_pin(pin);
    if (index == NULL) return;
    gpio_bit_toggle(index->gpio_periph, index->pin);
}

void gpio_clk_enable(uint32_t pin) {
    const struct pin_index *index = get_pin(pin);
    if (index == NULL) return;
    rcu_periph_clock_enable(index->clk);
}

void bsp_gpio_af_set(uint32_t pin, uint32_t alt_func_num) {
    const struct pin_index *index = get_pin(pin);
    if (index == NULL) return;
    gpio_af_set(index->gpio_periph, alt_func_num, index->pin);
}



/**
  * @brief  pin write
  * @param  irqno
  * @retval None
  */
static inline void pin_irq_hdr(int irqno) {
    if (pin_irq_hdr_tab[irqno].hdr) {
        pin_irq_hdr_tab[irqno].hdr(pin_irq_hdr_tab[irqno].args);
    }
}

/**
  * @brief  gd32 exit interrupt
  * @param  exti_line
  * @retval None
  */
void GD32_GPIO_EXTI_IRQHandler(int8_t exti_line) {
    if (RESET != exti_interrupt_flag_get((exti_line_enum) (1 << exti_line))) {
        pin_irq_hdr(exti_line);
        exti_interrupt_flag_clear((exti_line_enum) (1 << exti_line));
    }
}

void EXTI0_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(0);
    BSP_EXIT_CRITICAL;
}

void EXTI1_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(1);
    BSP_EXIT_CRITICAL;
}

void EXTI2_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(2);
    BSP_EXIT_CRITICAL;
}

void EXTI3_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(3);
    BSP_EXIT_CRITICAL;
}

void EXTI4_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(4);
    BSP_EXIT_CRITICAL;
}

void EXTI5_9_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(5);
    GD32_GPIO_EXTI_IRQHandler(6);
    GD32_GPIO_EXTI_IRQHandler(7);
    GD32_GPIO_EXTI_IRQHandler(8);
    GD32_GPIO_EXTI_IRQHandler(9);
    BSP_EXIT_CRITICAL;
}

void EXTI10_15_IRQHandler(void) {
    BSP_DEF_CRITICAL_SECTION;
    BSP_ENTER_CRITICAL;
    GD32_GPIO_EXTI_IRQHandler(10);
    GD32_GPIO_EXTI_IRQHandler(11);
    GD32_GPIO_EXTI_IRQHandler(12);
    GD32_GPIO_EXTI_IRQHandler(13);
    GD32_GPIO_EXTI_IRQHandler(14);
    GD32_GPIO_EXTI_IRQHandler(15);
    BSP_EXIT_CRITICAL;
}

示例程序

#define LED0 PB4

void bsp_io_led_init(void){
    gpio_write(LED0, PIN_LOW);
    gpio_mode(LED0, PIN_MODE_OUTPUT);

    while (1){
        delay_1ms(1000);
        gpio_toggle(LED0);
    }
    
}
詩不诉卿
关注
专栏目录
使用CLion搭建GD32开发环境(ARMClang)
Jelin’s Blog
10-12 6485
食材 CLion OpenOCD Keil arm-none-eabi 工具链 MinGW 简单的介绍一下食材 CLion 世界最好的C/C++ IDE(VisualStudio也拦不住，我说的！????) 这里列举我最喜欢的地方： 内置CMake Vim模式（虽然我是个Vim菜鸡????） 各种花里胡哨的插件（巧了，我就是喜欢花里胡哨） 高度可定制外观（鲁迅：颜值是第一生产力） OpenOCD 没啥好说的，负责下载程序。 Keil 这里详细说明一下，博主我用的是GD
CLion-GD32-ARMClang.zip
10-13
使用CLion作为GD32开发环境的模板，使用ARMClang作为编译器，板上调试可用，可以作为GD32项目开发模板，脱离Keil开发
clion调试gd32程序注意事项
weixin_43026921的博客
08-01 249
clion使用gdb调试gd32
clion开发threadx+gd32f425驱动(串口驱动)
scl8295的博客
08-18 252
【代码】clion开发threadx+gd32f425驱动(串口驱动)
【GD32】从0开始学GD32单片机（1）—— 环境搭建（Keil 5）
JackieCoo的博客
09-08 6895
介绍GD32的环境搭建
GD32F系列单片机开发总结（一）：编译环境的注意事项
ZhaoYongCheng的博客
06-25 6231
在打开官​​​​​​​网下载的demo后发现直接打开出现了错误，错误提示如下： 出现这错误的原因是由于编译环境的变化引起的，官方的demo开发环境是keil4，而我们现在使用的是keil5，修改的方法很简单。 首先找到工程目录，如图 然后将.uvproj后缀名称改为.uvproix，如图 再次打开就可以正常编译了。 ...
基于GD32F4实现二轮平衡车，开发环境CLion_&_gcc-arm-none-eabi10.3_
最新发布
09-02
基于GD32F4实现二轮平衡车，开发环境CLion_&_gcc-arm-none-eabi10.3_gd32_balance_bike.zip基于GD32F4实现二轮平衡车，开发环境CLion_&_gcc-arm-none-eabi10.3_gd32_balance_bike.zip 基于GD32F4实现二轮平衡车，...
这是一个在CLion编辑器中开发GD32F407点灯模版代码。_gd32_template_clion_led.zip
09-01
这是一个在CLion编辑器中开发GD32F407点灯模版代码。_gd32_template_clion_led
基于Clion STM32+RTOS+LVGL
04-05
基于Clion STM32+RTOS+LVGL - Clion-2022.3.2 - **MinGW** \------ 编译器套件 - **OpenOCD** ------ 调试工具 - **arm-none-eabi-gcc** -------- 交叉编译工具链
Clion开发STM32F407ZGT6标准库.pdf
02-06
STM32F407ZGT6 是 STM32F4 系列中的高性能微控制器之一，采用 ARM Cortex-M4 内核，并支持浮点运算单元 (FPU)，适用于各种复杂的实时控制应用。本文将详细介绍如何使用 JetBrains 的 Clion 集成开发环境 (IDE) 进行 ...
GD32F407-GCC编译模板，包含配置文件
10-27
在vscode下使用armgcc编译gd32f407程序，包含相关配置文件，经过测试可以下载、调试。
GD32库-GPS模块驱动代码.zip
01-12
本人博客《GD32F103c8t6串口读取GPS模块数据并经纬度(USART0、USART1串口接收和发送数据)教程-文章末尾有完整代码和工程文件》的完整工程文件。内含使用GD32库函数开发的GPS模块驱动代码。
GD32H7xx系列CLion FreeRTOS工程模版
08-08
GD32H7xx系列CLion FreeRTOS工程模版
【Clion】CLion安装与基于STM32使用CLion实现点亮流水灯
YangMax1的博客
12-19 847
目录一、CLion下载与安装1.CLion简介2.CLion下载与安装3.安装配置gcc4.安装配置OpenOCD5.配置CLion二、在CLion中使用CubeMX三、使用CLion进行点灯1.配置工程四、总结五、参考 一、CLion下载与安装 1.CLion简介   Clion是一款专门开发C以及C++所设计的跨平台的IDE。它是以IntelliJ为基础设计的，包含了许多智能功能来提高开发人员的生产力。这种强大的IDE帮助开发人员在Linux、OS X和Windows上来开发C/C++,同时它还能使用智
Clion2021的安装并实现stm32F103点亮LED
qq_54496810的博客
12-13 803
安装Clion2021，采用一套新的嵌入式软件开发工具包（替代Keil），完成stm32F103 点亮LED的程序
【系列文章模板】标题示例：Python 机器学习入门之pandas的使用
weixin_47064102的博客
08-03 1021
文章目录前言一、pandas是什么？二、使用步骤总结 前言 随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 正文： 一、pandas是什么？ pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素
Clion使用ARMClang编译（STM32F1、F4）
心之所向
04-16 3249
Clion使用ARMClang编译（STM32F1、F4）
52、window10环境下使用Clion(Ming32)生成含有opencv工程的静态库，供VSCode的进行联调处理(实际工程需要在GO中调用)
sxj731533730
09-04 673
基本思想：编译一个含有opencv第三方的静态库,提供给go语言进行连编译和调试（前提你已经安装了mingw32，同时使用mingw32编译了opencv） 一、测试一个完整的clion工程，读取图片并写入本地代码 cmakelists.txt cmake_minimum_required(VERSION 3.16) project(untitled6) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") set(OpenCV_DIR "D
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

詩不诉卿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值