AB32VG1开发板不支持IO中断吗？

发布于 2021-07-31 15:47:48 浏览：797 订阅该版

key.h文件内容
```c
#ifndef APPLICATIONS_KEY_H_
#define APPLICATIONS_KEY_H_
#include <rtthread.h>
#include "board.h"

typedef struct Key_s{
    uint8_t S2;
    uint8_t S3;
} Key_t;

#define DEBUG   1

void Key_Init(void);
int Read_S2(void);
int Read_S3(void);

#endif /* APPLICATIONS_KEY_H_ */
```
key.c文件内容：
```c
#include"key.h"
#include"led.h"

Key_t Key;

void Key_Init(void){
    Key.S3= rt_pin_get("PF.0");
    Key.S2 = rt_pin_get("PF.1");
    // 上拉输入
    rt_pin_mode(Key.S2, PIN_MODE_INPUT_PULLUP );
    rt_pin_mode(Key.S3, PIN_MODE_INPUT_PULLUP );
}

int Read_S2(void){
    return rt_pin_read(Key.S2);
}

int Read_S3(void){
    return rt_pin_read(Key.S3);
}

void S2_Interrput(void *args){
    rt_kprintf("S2 OK");
    Blue(1);
}

void S3_Interrput(void *args){
    rt_kprintf("S3 OK");
    Green(1);
}
// GPIO中断初始化
void Key_Interrput_Init(void){
    /* 绑定中断，下降沿模式，回调函数名为S2_Interrput */
    rt_pin_attach_irq(Key.S2, PIN_IRQ_MODE_FALLING, S2_Interrput, RT_NULL);
    /* 使能中断 */
    rt_pin_irq_enable(Key.S2, PIN_IRQ_ENABLE);
    /* 绑定中断，下降沿模式，回调函数名为S3_Interrput */
    rt_pin_attach_irq(Key.S3, PIN_IRQ_MODE_FALLING, S3_Interrput, RT_NULL);
    /* 使能中断 */
    rt_pin_irq_enable(Key.S3, PIN_IRQ_ENABLE);

}
// 测试
static struct rt_thread key_thread;  //创建一个静态线程控制块
ALIGN(RT_ALIGN_SIZE)  // 线程栈字节对齐
static uint8_t key_thread_stack[512];

static void key_thread_entry(void *parameter);  // 线程函数

static void key_thread_entry(void *parameter){
    Key_Init();
    led_init();
    Red(1);
    Key_Interrput_Init();
    while(1){
//        if (Read_S2()==PIN_LOW) {
//            Blue(1);
//        }
//        if (Read_S3()==PIN_LOW) {
//            Green(1);
//        }
        rt_thread_mdelay(100);
    }
}

static int Key_Thread_Init(void){
    rt_err_t status = rt_thread_init(&key_thread,
                        "key_thread",
                        key_thread_entry,
                        RT_NULL,
                        key_thread_stack,
                        sizeof(key_thread_stack),
                        10, 10);
    RT_ASSERT(status != RT_ERROR);
    rt_thread_startup(&key_thread);
    return 0;
}
INIT_APP_EXPORT(Key_Thread_Init);  // 初始化线程
```
led.h文件内容：
```
#ifndef APPLICATIONS_LED_H_
#define APPLICATIONS_LED_H_

#include <rtthread.h>
#include "board.h"

#define ON     PIN_LOW
#define OFF    PIN_HIGH

#define LED_G   "PE.4"
#define LED_B   "PA.1"
#define LED_R   "PE.1"

#define G_PIN   rt_pin_get(LED_G)
#define B_PIN   rt_pin_get(LED_B)
#define R_PIN   rt_pin_get(LED_R)

typedef struct led_s
{
    uint8_t R;
    uint8_t G;
    uint8_t B;
}led_t;

void led_init(void);
void Red(rt_bool_t on);
void Green(rt_bool_t on);
void Blue(rt_bool_t on);

int Thread_RGB(void);

#endif /* APPLICATIONS_LED_H_ */
```
led.c文件内容：
```
#include"led.h"

led_t Led;

void led_init(void)
{
    Led.R = rt_pin_get("PE.1");
    Led.G = rt_pin_get("PE.4");
    Led.B = rt_pin_get("PA.1");
    // 设置引脚为输出方式
    rt_pin_mode(Led.R, PIN_MODE_OUTPUT);
    rt_pin_mode(Led.G, PIN_MODE_OUTPUT);
    rt_pin_mode(Led.B, PIN_MODE_OUTPUT);
}

void Red(rt_bool_t on)
{
    rt_pin_write(Led.B,PIN_HIGH);
    rt_pin_write(Led.G,PIN_HIGH);
    if(on)
    {
        rt_pin_write(Led.R,PIN_LOW);
    }
    else
    {
        rt_pin_write(Led.R,PIN_HIGH);
    }

}

void Green(rt_bool_t on)
{
    rt_pin_write(Led.R,PIN_HIGH);
    rt_pin_write(Led.B,PIN_HIGH);
    if(on)
    {
        rt_pin_write(Led.G,PIN_LOW);
    }
    else
    {
        rt_pin_write(Led.G,PIN_HIGH);
    }

}

void Blue(rt_bool_t on)
{
    rt_pin_write(Led.R,PIN_HIGH);
    rt_pin_write(Led.G,PIN_HIGH);
    if(on)
    {
        rt_pin_write(Led.B,PIN_LOW);
    }
    else
    {
        rt_pin_write(Led.B,PIN_HIGH);
    }

}

static void rgb_thread_entry(void *p)
{
    led_init();
    while (1)
    {
        Red(1);
        rt_thread_mdelay(1000);
        Green(1);
        rt_thread_mdelay(1000);
        Blue(1);
        rt_thread_mdelay(1000);
    }
}

int Thread_RGB(void)
{
    rt_thread_t led_thread = RT_NULL;
    led_thread = rt_thread_create("led",rgb_thread_entry,RT_NULL,512,10,10);
    if(led_thread == RT_NULL)
    {
        rt_kprintf("Thread_RGB creat fail");
        return RT_ERROR;
    }
    rt_thread_startup(led_thread);
}

//INIT_APP_EXPORT(Thread_RGB);
```

经过测试，发现按键绑定中断，下降沿模式，没有起作用，不会调用中断回调函数，而当我把key.c里while(1)的按键扫描函数注释放开，使用按键扫描方式读IO状态，按键就能控制LED灯切换