驱动——按键中断控制LED灯实验

最新推荐文章于 2024-08-23 08:00:00 发布

犩未

最新推荐文章于 2024-08-23 08:00:00 发布

阅读量3.8k

点赞数 1

分类专栏：驱动开发文章标签： linux 嵌入式硬件驱动开发 stm32

本文链接：https://blog.csdn.net/ww1106/article/details/128085963

版权

驱动开发专栏收录该内容

8 篇文章 1 订阅

订阅专栏

三个按键实现按键中断

要求：按键按一下灯亮，再按一下灯灭

注：由于开发板位置，为了方便一一对应观察，采用key1控制LED3，key2控制LED2，key3控制LED1

0、添加相关设备树节点信息

①按键相关引脚，通过原理图可得：

key1------>gpiof9;

key2------>gpiof7;

key3------>gpiof8

②LED灯相关引脚：

led1----->gpioe10;

led2------>gpiof10;

led3------>gpioe8;

③编写完成之后在内核顶层目录下执行make dtbs重新生成设备树二进制文件

cp arch/arm/boot/dts/stm32mp157a-fsmp1a.dtb ~/tftpboot

④ 重新启动开发板

  myleds{
      myled1 = <&gpioe 10 0>;
      myled2 = <&gpiof 10 0>;
      myled3 = <&gpioe 8 0>;
  };

  myirq{
      interrupt-parent = <&gpiof>;
      interrupts = <7 0>,<8 0>,<9 0>;
  };

1、获取设备树节点

本次采用通过名字进行获取（具体详情见gpio子系统（LED灯的操控实验））

2、从节点信息中解析出软中断号

int irq_of_parse_and_map(struct device_node *dev, int index)

功能：解析设备树节点信息获取软中断号

参数：

dev:设备树节点信息结构体指针

index:中断的索引号

返回值：成功返回软中断号，失败返回0

3、将要使用的中断注册进内核

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev)

功能：注册中断

参数：

        irq:软中断号

        handler:中断处理函数 //typedef irqreturn_t (*irq_handler_t)(int, void *);

                //中断处理函数返回值：

                        //IRQ_NONE //中断不是设备处理或者没处理

                        //IRQ_HANDLED //中断正常处理

                        //IRQ_WAKE_THREAD //开启中断处理线程

        flags:中断触发的方式

                IRQF_TRIGGER_RISING//上升沿触发

                IRQF_TRIGGER_FALLING//下降沿触发

                IRQF_TRIGGER_HIGH//高电平触发

                IRQF_TRIGGER_LOW//低电平触发

        name：中断的名字//自己指定

                sudo cat /proc/interrupts

        dev：在这个函数里传给中断处理函数的参数，根据情况决定给是否使用

返回值：成功返回0，失败返回错误码

4、注销中断

void *free_irq(unsigned int irq, void *dev_id)

功能：注销中断

参数：

irq:软中断号 d

ev_id:向中断处理函数中传递的参数

返回值：返回设备名

5、具体代码实现

#include<linux/init.h>
#include<linux/module.h>
#include<linux/of.h>
#include<linux/of_gpio.h>
#include<linux/gpio.h>
#include<linux/fs.h>
#include<linux/uaccess.h>
#include<linux/io.h>
#include<linux/cdev.h>
#include<linux/slab.h>
#include<linux/timer.h>
#include<linux/of_irq.h>
#include<linux/interrupt.h>
#include"./six.h"

#define GNAME "mydev"


unsigned int irqno1;//用于接收软中断号
unsigned int irqno2;//用于接收软中断号
unsigned int irqno3;//用于接收软中断号
unsigned int num=0;

//定义一个底半部
struct tasklet_struct tasklet;

irqreturn_t irq_handler1(int irqno,void *dev)
{
    num++;
    printk("key1 interrupt %d ...\n",num);
    gpiod_set_value(gpiono1,(!gpiod_get_value(gpiono1)));
    return IRQ_HANDLED;
}
irqreturn_t irq_handler2(int irqno,void *dev)
{
    num++;
    printk("key2 interrupt %d ...\n",num);
    gpiod_set_value(gpiono2,(!gpiod_get_value(gpiono2)));
    return IRQ_HANDLED;
}
irqreturn_t irq_handler3(int irqno,void *dev)
{
    num++;
    printk("key3 interrupt %d ...\n",num);
    gpiod_set_value(gpiono3,(!gpiod_get_value(gpiono3)));
    return IRQ_HANDLED;
}
static int __init mynode_init(void)
{
   
    int ret;
    //通过名字获取设备树节点信息
    node = of_find_node_by_name(NULL,"myirq");
    if(NULL == node)
    {
        printk("of find node by name error\n");
        return -EFAULT;
    }
    //根据设备树节点获取软中断号1
    irqno1 = irq_of_parse_and_map(node,1);
    if(irqno1==0)
    {
        printk("irq of parse and map error\n");
        return EINVAL;
    }
    printk("irq of parse and map success\n");
    //根据设备树节点获取软中断号2
    irqno2 = irq_of_parse_and_map(node,0);
    if(irqno2==0)
    {
        printk("irq of parse and map error\n");
        return EINVAL;
    }
    printk("irq of parse and map success\n");
    //根据设备树节点获取软中断号3
    irqno3 = irq_of_parse_and_map(node,2);
    if(irqno3==0)
    {
        printk("irq of parse and map error\n");
        return EINVAL;
    }
    printk("irq of parse and map success\n");
    //将要使用的中断注册进内核
    ret = request_irq(irqno1,irq_handler1,IRQF_TRIGGER_FALLING,"key",NULL);
    if(ret)
    {
        printk("request irq irqno1 error\n");
        return ret;
    }
    //将要使用的中断注册进内核
    ret = request_irq(irqno2,irq_handler2,IRQF_TRIGGER_FALLING,"key",NULL);
    if(ret)
    {
        printk("request irq irqno1 error\n");
        return ret;
    }
    //将要使用的中断注册进内核
    ret = request_irq(irqno3,irq_handler3,IRQF_TRIGGER_FALLING,"key",NULL);
    if(ret)
    {
        printk("request irq irqno1 error\n");
        return ret;
    }
     //通过名字获取设备树节点信息
    node = of_find_node_by_name(NULL,"myleds");
    if(NULL == node)
    {
        printk("of find node by name error\n");
        return -EFAULT;
    }
    //获取并申请LED1的gpio编号
    gpiono1 = gpiod_get_from_of_node(node,"myled1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono1))
    {
        printk("1gpiod get from of node error\n");
        return PTR_ERR(gpiono1);
    }
    //获取并申请LED2的gpio编号
     gpiono2 = gpiod_get_from_of_node(node,"myled2",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono2))
    {
        printk("2gpiod get from of node error\n");
        return PTR_ERR(gpiono2);
    }
    //获取并申请LED3的gpio编号
     gpiono3 = gpiod_get_from_of_node(node,"myled3",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono3))
    {
        printk("3gpiod get from of node error\n");
        return PTR_ERR(gpiono3);
    }
    
    return 0;
    
}

static void __exit mynode_exit(void)
{
   
    //注销中断1
    free_irq(irqno1,NULL);
    //注销中断1
    free_irq(irqno2,NULL);
    //注销中断1
    free_irq(irqno3,NULL);
    //卸载驱动前熄灭灯LED1
    gpiod_set_value(gpiono1,0);
        //卸载驱动前熄灭灯LED1
    gpiod_set_value(gpiono2,0);
        //卸载驱动前熄灭灯LED1
    gpiod_set_value(gpiono3,0);
        
    //释放申请得到的LED1gpio编号
    gpiod_put(gpiono1);
        //释放申请得到的LED2gpio编号
    gpiod_put(gpiono2);
        //释放申请得到的LED3gpio编号
    gpiod_put(gpiono3);
        

}

module_init(mynode_init);
module_exit(mynode_exit);

MODULE_LICENSE("GPL");

头文件代码：

#ifndef __LED_H__
#define __LED_H__

#define LED_ON _IOW('a',1,int)
#define LED_OFF _IOW('a',0,int)


struct device_node *node;
struct gpio_desc *gpiono1;
struct gpio_desc *gpiono2;
struct gpio_desc *gpiono3;
int ret;

typedef enum{
    LED1,
    LED2,
    LED3,  
}led_t;

#endif

makefile脚本文件见gpio子系统（LED灯的操控实验）

6、实验现象

见按键中断控制LED灯实验现象