Linux驱动（中断、异步通知）：红外对射，并在Qt StatusBus使用指示灯进行显示

本文工作：

1、Linux驱动与应用程序编写：使用了设备树、中断、异步通知知识点，实现了红外对射状态的异步信息提醒。

2、QT程序编写：自定义了一个“文本指示灯”类，并放置在QMainWidget的StatusBus中。

3、C与C++混合编程与调试：将Linux C下的面向过程转化为QT C++的面向对象。但是Linux C下signal函数需要使用static函数作为传入参数，但是C++中static的用法与C语言不一样，因此在C++中对抽象出的类进行了适配与修改。

参考资料

1、《正点原子：I.MX6U嵌入式Linux驱动开发指南V1.6》

2、C/C++ static关键字详解（最全解析，static是什么，static如何使用，static的常考面试题）-CSDN博客

3、【创龙AM4379 Cortex-A9试用体验】之I/O中断异步通知驱动程序+QT捕获Linux系统信号+测试信号通知 - ARM技术论坛 - 电子技术论坛 - 广受欢迎的专业电子论坛! (elecfans.com)

4、Qt 封装一个简单的LED(指示灯)控件_qt 指示灯-CSDN博客

本文不对基础知识进行讲解，因此阅读本文需要一定的驱动/QT基础。

开发板：IMX6ULL

内核版本：4.1.15

QT版本：5.12

一、项目需求与效果

1、项目需求：

项目中的一个简单传感器：使用红外对射，检查物品是否放入了盒子中，并在QT界面的statusBus中，使用指示灯的形式进行显示与说明。

2、代码效果

代码效果：屏幕左下角文本指示灯的变化

二、Linux驱动与应用程序编写

1、使用引脚说明

本次所使用的引脚为GPIO2_2，查看了I.MX6ULL核心板对GPIO的描述，该引脚可复用到GPIO1_IO02引脚上，因此我们需要先修改下设备树的文件。

2、修改设备树文件

在根节点目录下先添加节点：

gpio_infrared {
		compatible = "csx-gpio-infrared";
		pinctrl-names = "default";
		pinctrl-0 = <&pinctrl_infrared>;
		infrared-gpio = <&gpio1 2 GPIO_ACTIVE_LOW>;
		interrupts = < IRQ_TYPE_EDGE_BOTH>;
		status = "okay";
	};

项目中，我们需要极度关注是否有物体存入，进拿进取出都需要通知用户，因此需要中断类型使用IRQ_TYPE_EDGE_BOTH。

其中的pinctrl_infrared为：

pinctrl_infrared: infraredgrp {
		fsl,pins = <
		MX6UL_PAD_GPIO1_IO02__GPIO1_IO02 0x10B0
		>;
		};	

修改完之后，执行make dtbs，更换开发板的设备树之后，我们使用 ls /proc/device-tree查看是否有我们增加的设备树节点。

如上图，设备树修改成功，接下来就是编写驱动文件。

3、驱动文件编写

（1）结构体编写

/* 设备中断结构体 */
struct irq_gpio_infrared{
	int gpio;				/* gpio */
	int irqnum;				/* 中断号 */
	unsigned char value;	/* 读取的值 */
	char name[10];			/* 名字 */
	irqreturn_t (*handler)(int,void *); /* 中断服务函数 */
	
};

/* gpioinfrared设备结构体 */
struct gpio_infrared_dev{
	dev_t devid;			/* 设备号 	 */
	struct cdev cdev;		/* cdev 	*/
	struct class *class;	/* 类 		*/
	struct device *device;	/* 设备 	 */
	int major;				/* 主设备号	  */
	int minor;				/* 次设备号   */
	struct device_node	*nd; /* 设备节点 */
	struct irq_gpio_infrared irqgpioinfrared;	/* 中断结构体 */
	struct fasync_struct *async_queue; /* 异步相关结构体 */
};


struct gpio_infrared_dev gpioinfrared;	/* infrared设备 */

代码中我们需要注意的是，使用了中断结构体，用于红外对射，检测到物体时通知用户，在各种通知方法中，使用异步通知是最可行的，其他方法需要占据大量的cpu资源，不适合本次的应用场景，因此，中断服务其实就是使用异步通知对用户进行通知，因此，我们还需要使用异步通知的结构体。

（2）获取设备树节点的信息【设备树API、GPIO子系统API】

	/* 1、获取设备节点：gpioinfrared */
	gpioinfrared.nd = of_find_node_by_path("/gpio_infrared");
	if(gpioinfrared.nd == NULL) {
		printk("gpioinfrared node not find!\r\n");
		return -EINVAL;
	} else {
		printk("gpioinfrared node find!\r\n");
	}

	/* 2、 获取设备树中的gpio属性，得到GPIO所使用的编号 */
	gpioinfrared.irqgpioinfrared.gpio = of_get_named_gpio(gpioinfrared.nd, "infrared-gpio", 0);
	if(gpioinfrared.irqgpioinfrared.gpio < 0) {
		printk("can't get infrared-gpio");
		return -EINVAL;
	}else{
		printk("infrared-gpio num = %d\r\n", gpioinfrared.irqgpioinfrared.gpio);
	}
	
	/* 3、初始化使用的gpio */
	memset(gpioinfrared.irqgpioinfrared.name,0,sizeof(gpioinfrared.irqgpioinfrared.name));
	sprintf(gpioinfrared.irqgpioinfrared.name,"gpioinfrared%d",i);
	ret = gpio_direction_input(gpioinfrared.irqgpioinfrared.gpio);
	if(ret < 0) {
		printk("can't set gpio!\r\n");
	}

（3）中断申请

	/* 4、设置中断模式，返回中断号 */
	gpioinfrared.irqgpioinfrared.irqnum = gpio_to_irq(gpioinfrared.irqgpioinfrared.gpio);
	printk("gpio:%d,irq:%d",gpioinfrared.irqgpioinfrared.gpio,gpioinfrared.irqgpioinfrared.irqnum);
	/* 申请中断 */
	gpioinfrared.irqgpioinfrared.handler = goio_infrared_handler;
	ret = request_irq(gpioinfrared.irqgpioinfrared.irqnum, 
					  gpioinfrared.irqgpioinfrared.handler, 
		              IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
					  gpioinfrared.irqgpioinfrared.name, 
					  &gpioinfrared);
	if(ret < 0){
		printk("irq %d request fail infrared!\r\n", gpioinfrared.irqgpioinfrared.irqnum);
		printk("irq_name: %s\r\n",gpioinfrared.irqgpioinfrared.name);
		return -EFAULT;
	}
	if (ret==-EBUSY){
		printk("irq already apply\r\n");
	}

（4）编写红外对射的中断函数

/*
	GPIO红外中断服务函数，用于发送异步信息
*/
static irqreturn_t goio_infrared_handler(int irq,void *dev_id)
{
	struct gpio_infrared_dev *dev = (struct gpio_infrared_dev *)dev_id;

	printk("irq happend!\r\n");
	kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
	return IRQ_RETVAL(IRQ_HANDLED);
}

如上述所说，就是用于发送异步通信的！在这里还使用内核进行打印输出，方便检测。

（5）编写异步通信函数

static int imx6uirq_fasync(int fd, struct file *filp, int on)
{
	struct gpio_infrared_dev *dev = (struct gpio_infrared_dev *)filp->private_data;
	return fasync_helper(fd, filp, on, &dev->async_queue);
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
	return imx6uirq_fasync(-1, filp, 0);
}

（6）编写用户层数据接口

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t infrared_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	int ret = 0;
	unsigned char value=-1;
	struct gpio_infrared_dev *dev = (struct gpio_infrared_dev *)filp->private_data;
	value = gpio_get_value(dev->irqgpioinfrared.gpio);
	printk("gpioinfrared read:%d!\r\n",value);
	ret = copy_to_user(buf, &value, sizeof(value));
	return ret;
}

重点的内容都介绍完了，接下来就是检查下是否正确驱动编写是否正确了！make生成.ko文件后，传到开发板，使用insmod命令，会有如下输入：

此时，我们将红外进行对射后，就会有如下输出：

即驱动编写正确。接下来，我们先编写应用程序的代码，接收异步通知的提醒。

4、Linux C应用程序代码编写

应用程序接收异步通知需要以下三个步骤：

（1）使用signal函数设置（驱动程序所使用的）信号处理函数；

（2）将当前应用程序的内核号告知内核

（3）开启异步通知

signal(SIGIO, sigio_signal_func);   /* 设置信号SIGIO的处理函数     */
fcntl(fd, F_SETOWN, getpid());		/* 设置当前进程接收SIGIO信号   */
flags = fcntl(fd, F_GETFL);			/* 获取当前的进程状态 		  */
fcntl(fd, F_SETFL, flags | FASYNC);	/* 设置进程启用异步通知功能 	  */	

/*
 * SIGIO信号处理函数
 * @param - signum 	: 信号值
 * @return 			: 无
 */
static void sigio_signal_func(int signum)
{
	int err = 0;
	unsigned int infrared_value = 0;
	err = read(fd, &infrared_value, sizeof(infrared_value));
	if(err < 0) {
		/* 读取错误 */
		printf("read error!\r\n");
	} else {
		printf("sigio signal:%d!\r\n",infrared_value);
	
	}
	
}

上图所示，测试成功！

三、C++ Qt程序编写

1、自定义LedWithText

?先根据自己的需要，对参考资料第四点对自封装的LED控件进行了简化，类名为QSimpleLed

QSimpleLed.cpp文件

#include "qsimpleled.h"

#include <QGradient>
#include <QPainter>
#include <QDebug>
#include <QColor>


QSimpleLed::QSimpleLed(QWidget *parent, QColor color,int radius)
    : QLabel(parent)
    , mColor(color)
{
    setMinimumSize(radius, radius);
    setMaximumSize(radius,radius);
}

void QSimpleLed::setStates(QSimpleLed::LEDSTATES states)
{
    switch (states) {
    case ON:
        resetStatus();

        mStates = ON;
        break;

    case OFF:
        resetStatus();
        break;

    case BLINK:
        resetStatus();

        if (!mBlinkTimer) {
            mBlinkTimer = new QTimer(this);
            connect(mBlinkTimer, &QTimer::timeout, this, &QSimpleLed::onBlinkTimerTimeout);
        }
        mBlinkTimer->setInterval(mInterval);
        mBlinkTimer->start();
        mStates = BLINK;
        break;

    default:
        qDebug() << "LED - unknown states!!!";
    }

    update();
}

void QSimpleLed::setColor(QColor color)
{
    mColor = color;
}



void QSimpleLed::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);

    qreal realSize = qMin(width(), height());
    QPainter painter(this);

    painter.setRenderHint(QPainter::Antialiasing);      // 反锯齿
    painter.translate(width()/2, height()/2);           // 绘点移到控件中心处


    if(blinkState)
        painter.setBrush(QBrush(QColor(111,111,111)));
    else
        painter.setBrush(QBrush(mColor));

    painter.drawEllipse(QPointF(0, 0), realSize/2, realSize/2);

}

void QSimpleLed::resizeEvent(QResizeEvent *event)
{
    Q_UNUSED(event);
    update();
}



void QSimpleLed::onBlinkTimerTimeout()
{
    blinkState = !blinkState;
    update();
}

void QSimpleLed::resetStatus()
{
    if (mBlinkTimer && mBlinkTimer->isActive()) {
        mBlinkTimer->stop();
    }
    mStates = OFF;
}

QSimpleLed.h文件

#ifndef QSIMPLELED_H
#define QSIMPLELED_H

#include <QLabel>
#include <QTimer>
#include <QColor>

class QSimpleLed : public QLabel
{
    Q_OBJECT


public:

    enum LEDSTATES {
        ON       = 0,
        OFF      = 1,
        BLINK    = 2,
    };


    QSimpleLed(QWidget *parent = nullptr, QColor color = Qt::green,int radius=16);

    void setStates(LEDSTATES states);
    void setInterval(int msec) { mInterval = msec; }
    void setColor(QColor color);

protected:
    virtual void paintEvent(QPaintEvent *event) override;
    virtual void resizeEvent(QResizeEvent *event) override;

private slots:
    void onBlinkTimerTimeout();

private:
    void resetStatus();

    LEDSTATES mStates = OFF;
    QColor mColor;
    QTimer *mBlinkTimer = nullptr;
    int mInterval = 500;
    bool blinkState = false;

};



#endif // QSIMPLELED_H

再根据自己的需求，自定义一个widget，用于存放led（左）与text（右），我们在外部只需要传入led的状态、颜色、文本的内容即可，该类的名称为LedWithText。

LedWithText.cpp

#include "ledwithtext.h"
#include <QFont>
#include <QDebug>

ledWithText::ledWithText(QWidget *parent, QColor color, const QString &text)
    :QWidget(parent)
{


    ledLabel = new QSimpleLed(this);
    ledLabel->setColor(color);
//    ledLabel->setStyleSheet("border-width: 1px;border-style: solid;border-color: rgb(255, 170, 0);");

    textLabel = new QLabel(text,this);
    textLabel->adjustSize();
    textLabel->setAlignment(Qt::AlignVCenter);
    textLabel->setMinimumHeight(ledLabel->height()+5);
    textLabel->setVisible(!text.isEmpty());

    QFont ft;
    ft.setPointSize(14);
    textLabel->setFont(ft);

    layout = new QHBoxLayout(this);
    layout->addWidget(ledLabel);
    layout->addWidget(textLabel);
    layout->setSpacing(5);
    setLayout(layout);

    int adjustWith = ledLabel->width()+textLabel->width()+25;
    int adjustHeight = textLabel->height()+10;
//    qDebug()<<adjustHeight<<adjustWith;
    setGeometry(0,0,adjustWith,adjustHeight);
}

ledWithText::~ledWithText()
{
    delete  ledLabel;
    delete  textLabel;
}

void ledWithText::setLedColor(QColor color)
{
    ledLabel->setColor(color);
}

void ledWithText::setLedState(QSimpleLed::LEDSTATES states)
{
    ledLabel->setStates(states);
}



void ledWithText::setText(const QString &text)
{
    textLabel->setText(text);
    textLabel->adjustSize();
    textLabel->setVisible(!text.isEmpty());
    int adjustWith = ledLabel->width()+textLabel->width()+25;
    int adjustHeight = textLabel->height()+10;
    setGeometry(0,0,adjustWith,adjustHeight);
}

void ledWithText::setTextFontSize(int size)
{
    QFont ft;
    ft.setPointSize(size);
    textLabel->setFont(ft);
    textLabel->adjustSize();
    int adjustWith = ledLabel->width()+textLabel->width()+25;
    int adjustHeight = textLabel->height()+10;
    setGeometry(0,0,adjustWith,adjustHeight);
}

LedWithText.h

#ifndef LEDWITHTEXT_H
#define LEDWITHTEXT_H
#include <QLabel>
#include <ui_optimize/qsimpleled.h>
#include <QWidget>
#include <QHBoxLayout>

class ledWithText:public QWidget
{
    Q_OBJECT
public:
    ledWithText(QWidget *parent = nullptr, QColor color = Qt::green, const QString &text = "");
    ~ledWithText();
    void setLedColor(QColor color);
    void setLedState(QSimpleLed::LEDSTATES states);
    void setText(const QString &text);
    void setTextFontSize(int size);


private:
    QSimpleLed *ledLabel;
    QLabel *textLabel;
    QHBoxLayout *layout;
};

#endif // LEDWITHTEXT_H

2、使用MainWidget的StatusBus存放文本指示灯

我们要把这些控件放置在状态栏中，不管切换到什么界面都可以看到，就不需要一直重复写代码了，因此，我们需要使用MainWidget的StatusBus，Widget类没有StatusBus！不要用错。

void MainWindow::state_bus_init()
{
    device_connect_label = new ledWithText(this,Qt::green,"设备正在连接");
    device_connect_label->setLedColor(Qt::blue);
    device_connect_label->setLedState(QSimpleLed::BLINK);
    device_connect_label->setTextFontSize(10);

    ui->statusbar->addWidget(device_connect_label);
    device_place_label = new ledWithText(this,Qt::green,"设备未放置");
    device_place_label->setTextFontSize(10);
    ui->statusbar->addWidget(device_place_label);
}

?就可以看到如下效果了。我们自定义的LedWithText类的效果就显示在左下角了。

3、Qt接受异步通知，并根据结果改变文本指示灯

按道理，最简单的做法，这一步只需要将应用层的代码搬过来就可以，但是在上文我们提到，在Linux C的应用程序中，signal函数需要传入static修饰的函数，但是Qt使用C++语言，想要将其转化为类（而不是面向过程），就需要解决static在C语言和C++的差异。

#include "infrareddev.h"


InfraredDev::InfraredDev(QObject *parent) : QObject(parent)
{
    fd = open(DEVNAME, O_RDWR);
    if (fd < 0) {
        qDebug()<<"Can't open file :"<<DEVNAME;

    }else{
        register_infrared_asy();
        qDebug()<<"infrared:init succeed!";
    }

}

InfraredDev::~InfraredDev()
{
    if(fd){
        close(fd);
    }
}

void InfraredDev::set_dev_name(char *name)
{
    dev_name = name;
}

char *InfraredDev::get_dev_name()
{
    return dev_name;
}

void InfraredDev::setLedWithText(ledWithText *obj)
{
    infrared_ledWithText = obj;
}

void InfraredDev::sigio_signal_func(int signum)
{
    int err = 0;
    unsigned int infrared_value = 0;
    err = read(fd, &infrared_value, sizeof(infrared_value));
    if(err < 0) {
//        InfraredDev instance; // 创建对象实例
//        emit instance.infraredSignal(infrared_value);
        /* 读取错误 */
        infrared_ledWithText->setLedColor(Qt::red);
        infrared_ledWithText->setLedState(QSimpleLed::BLINK);
        infrared_ledWithText->setText("获取设备失败");
        qDebug()<<"infrared:read error!";
    } else {
        if(infrared_value==0){
            infrared_ledWithText->setLedColor(Qt::green);
            infrared_ledWithText->setText("设备已放置");
        }else if(infrared_value==1){
            infrared_ledWithText->setLedColor(Qt::red);
            infrared_ledWithText->setLedState(QSimpleLed::BLINK);
            infrared_ledWithText->setText("设备未放置");
        }

        qDebug()<<"infrared:sigio signal!"<<infrared_value;

    }

}

void InfraredDev::register_infrared_asy()
{
    int flags = 0;
    /* 设置信号SIGIO的处理函数 */
    signal(SIGIO, &InfraredDev::sigio_signal_func);

    fcntl(fd, F_SETOWN, getpid());		/* 设置当前进程接收SIGIO信号 	*/
    flags = fcntl(fd, F_GETFL);			/* 获取当前的进程状态 			*/
    fcntl(fd, F_SETFL, flags | FASYNC);	/* 设置进程启用异步通知功能 	*/
}



int InfraredDev::fd = -1; // 初始化为无效的文件描述符
ledWithText *InfraredDev::infrared_ledWithText = nullptr;

#ifndef INFRAREDDEV_H
#define INFRAREDDEV_H


#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "linux/ioctl.h"
#include "signal.h"

#include <QObject>
#include <QDebug>
#include <QFile>
#include <QTextStream>
#include <QString>


#include "ui_optimize/ledwithtext.h"

#define DEVNAME "/dev/gpio_infrared"



class InfraredDev : public QObject
{
    Q_OBJECT
public:
    explicit InfraredDev(QObject *parent = nullptr);
    ~InfraredDev();
    void set_dev_name(char *name);
    char * get_dev_name();
    static ledWithText *infrared_ledWithText;
    static void setLedWithText(ledWithText *obj);


private:
    static int fd;	/* 文件描述符 */
    static QFile file;
    char *dev_name;
    static void sigio_signal_func(int signum);
    void register_infrared_asy(void);

};

#endif // INFRAREDDEV_H

因为static修饰的成员变量、成员函数并没有this指针，因此无法读取其他非static成员只允许读取static变量，因此我们需要将fd也需要使用static函数进行修饰，并且函数内不能包含其他no-static的变量。

因此在signal函数，我们就需要根据C++访问静态函数的规则，对参数进行传入了修改，使用通过（类名::静态成员）的方式来访问。

signal(SIGIO, &InfraredDev::sigio_signal_func);

?然后，我们需要让QMainwindow类知道，接收到异步通信了，需要刷新UI了。

（1）信号机制方法

我一开始是照常使用信号机制，定义了信号函数，使用emit函数进行发送，但是因为异步通知处理函数是static类的，无法直接调用其他non-static的成员，无法发送信号，因此我想是实例化一个类，发送类的实例，进而发送信号：

InfraredDev instance; // 创建对象实例
emit instance.infraredSignal(infrared_value);

代码没报错，但是执行过程出错了，在开发板上只能读取第一次的数值，发送后，就无法进行读取，由于是在开发板上进行运行的，无法进行debug，不知道是什么原因，如果有大神知道，还请不吝赐教！

（2）指针传入做法

之后，我看到了参考资料的3的做法，就想直接传入界面的指针，在异步通知里面，直接读取指针，进行界面的修改。因此我就根据，non-static成员函数可以访问static成员变量的特性，对该做法进行了改进。定义了一个设置控件的函数，外部传入一个控件指针，函数内部设置为static类型，因此完美解决了该问题。

void InfraredDev::setLedWithText(ledWithText *obj)
{
    infrared_ledWithText = obj;
}


// 在static函数就可以使用这个static指针进行设置了
void InfraredDev::sigio_signal_func(int signum){
   ......
   infrared_ledWithText->setLedColor(Qt::red);
   infrared_ledWithText->setLedState(QSimpleLed::BLINK);
   infrared_ledWithText->setText("设备未放置");

}

在infrared_dev.h中，存在该声明，为static成员变量

 static ledWithText *infrared_ledWithText;

那么，我们在外部只需要传入该控件的指针即可

device_connect_label = new ledWithText(this,Qt::green,"设备正在连接");

......
infrared_dev = new InfraredDev();
infrared_dev->setLedWithText(device_place_label);