本文工作：
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驱动-QT
代码效果：屏幕左下角文本指示灯的变化
二、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); /* 设置进程启用异步通知功能 */
在此处的异步处理函数就很简单了，使用GPIO子系统的API获取当前的引脚数值，但是值得一提的是，
signal函数的传入函数必须是使用static进行修饰的，在后面与C++代码对接时，就是因为static增加了不少的限制。
/*
* 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);
}
}接下来，我们在进行交叉编译之后
arm-linux-gnueabihf-gcc infrared_asy.c -o infrared_asy
进行测试一下。
上图所示，测试成功！
三、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);
![[NCTF2019]Fake XML cookbook1](https://img-blog.csdnimg.cn/direct/9863ccf9055f4931916a7a6d4a71f9a6.png)
