1. 实验思路

可以驱动的硬件有，3个按钮，RGB 小灯，需要通过按钮切换来实现这三个功能：

  • 切换灯颜色：可以通过按钮指定灯的颜色
  • 修改灯亮度：修改当前指定的灯的颜色的亮度

  • 渐变灯：可以通过按钮控制3原色的成分

    方案1

  • 按钮1：增加当前颜色的分量

  • 按钮2：减少当前颜色的分量

  • 按钮3：确定当前颜色，设置下个颜色

    2. 硬件与插线

    2.1 按键

    按键已经在开发底板上连接，一端连接的引脚是KEY1，KEY2， KEY3，另外一端连接的都是GND
    所以当按钮摁下的时候，变为低电平。
    这时候我们需要把KEY1，KEY2，KEY3 和 旁边的 GPIO21 GPIO06 GPIO07 连接

  • GPIO21 —> KEY1

  • GPIO07 —> KEY2

  • GPIO06 —> KEY3

    image.png
    image.png
    通过杜邦线把他们连接
    image.png
    image.png

    2.2 三色灯

    三色灯在电路板上已经连接上了树莓派：

  • GPIO29 —> LED_GREEN

  • GPIO28 —> LED_RED
  • GPIO27 —> LED_BLUE

三色灯的一端是GND，另外一端是上面对应的GPIO。将三色灯模块上的RGB对应连到地板上的LEDR，LEDG，LEDB，GND接地。
image.png
image.png

3. QT + WiringPi 基础

3.1 新建项目

image.png
image.png
image.png
image.png

3.2 加入wiringPi 支持

在.pro里面， 添加：

  1. LIBS += -lwiringPi

image.png
在cpp文件的构造函数内，初始化它：

  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include "wiringPi.h" // 引入头文件
  5. MainWindow::MainWindow(QWidget *parent) :
  6.     QMainWindow(parent),
  7.     ui(new Ui::MainWindow)
  8. {
  9.     ui->setupUi(this);
  10.     wiringPiSetup(); // 初始化
  11. }

4. 关键模块

4.1 按键读取

4.1.1 思路

检测按下：用定时器读取对应key引脚的GPIO，若变为低电平说明按下
检测松开： 一直等待电压变回高电平
防抖： 检测到电平变了后， 等一段时间再检测一次

4.1.2 宏定义

在mainwindow.h 里面 为三个按钮的 GPIO 定义宏：

  1. #define KEY1 21
  2. #define KEY2 07
  3. #define KEY3 06

image.png

4.1.3 相关api

  • pinmode()：设置引脚模式为输入。
  • pullUpDnControl() ：由于按下状态是低电平，要设置默认状态是高电平
  • digitalRead()：读取引脚电平
  • delay()：用于防抖的延时

4.1.4 初始化代码

初始化引脚模式并设置为高电平。因为按下接地是低电平，所以默认状态是高电平，需要通过pullUpDnControl来设置

  1. // init pin of keys
  2. pinMode(KEY1, INPUT);
  3. pinMode(KEY2, INPUT);
  4. pinMode(KEY3, INPUT);
  6. // set defalut mode is high 
  7. pullUpDnControl(KEY1, PUD_UP);
  8. pullUpDnControl(KEY2, PUD_UP);
  9. pullUpDnControl(KEY3, PUD_UP);

4.1.5 定义检查按键的函数

bool isClicked(int pin)

  • 传入参数是要检测的引脚
  • 传出参数是是否被按下
    1. bool MainWindow::isClicked(int pin){
    2.   if(digitalRead(pin) == 0){ // 0 是需要按下
    3.       delay(100);// 防抖
    4.       if(digitalRead(pin) == 0){
    5.           while (digitalRead(pin) == 0);
    6.           return true; // 返回的确是按下
    7.       }
    8.   }
    9.   return false; //  返回没有是按下
    10. }

4.1.6 定时器执行的槽函数

  1. /*mainwindows.h*/
  2. private slots:
  3.     void ReadKey1();
  4.     void ReadKey2();
  5.     void ReadKey3();
  7. /*mainwindows.cpp*/
  8. void MainWindow::ReadKey1(){
  9.     if(!isClicked(KEY1)){
  10.         return;
  11.     }
  12.     qDebug() << "key1 clicked";
  13. }
  15. void MainWindow::ReadKey2(){
  16.     if(!isClicked(KEY2)){
  17.         return;
  18.     }
  19.     qDebug() << "key2 clicked";
  21. }
  23. void MainWindow::ReadKey3(){
  24.     if(!isClicked(KEY3)){
  25.         return;
  26.     }
  27.     qDebug() << "key3 clicked";
  28. }

4.1.7 定义并初始化定时器

  1. /* mainwindows.h */
  2. public:
  3.     QTimer *timer;
  5. /* mainwindows.cpp */
  6. timer = new QTimer;
  7. connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey1));
  8. connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey2));
  9. connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey3));
  11. timer->start(50);

4.1.8 测试：

在完成以后，按下对应按键可以检测到：
image.png

4.2. PWM控制小灯

4.2.1 思路

对于单个灯，控制它在一个周期内的占比，就可以控制亮度
例如：一个周期是1000us， 亮500us， 灭500us，就是50%的亮度
一个周期是1000us， 亮800us， 灭200us，就是80%的亮度
因此有2个关键参数

  • 周期 ：period
  • 占空比：duty

周期确定了，调占空比就可以调亮度
因此可以基于wiringPi的softPwm，实现

4.2.2 宏定义

  1. #define LED_R 28
  2. #define LED_G 29
  3. #define LED_B 27
  4. #define PERIOD 1000

4.2.3 用到的api

  • softPwmCreate(int pin, int val , int ranger) 设置引脚是pwm模式，参数：
    • 第一个参数是引脚
    • 第二个参数是默认值
    • 第三个参数是最可以设置的值
  • softPwmWrite(int pin, int value)
    • 第一个参数是引脚
    • 第二个参数是要设置的值（不能超过最大值）

      4.2.4 初始化

      在.pro文件里面添加 LIBS += -lpthread
      image.png
      将3个引脚都设置成PWM模式
      在.cpp 文件内，引入softPwm头文件
      image.png
      1. // init pin of led
      2. // init pin of led
      3. softPwmCreate(LED_R, 0, 255);
      4. softPwmCreate(LED_G, 0, 255);
      5. softPwmCreate(LED_B, 0, 255);

4.2.5 控制亮度

这里只展示控制亮度的示例，具体和按键的结合会在下面给出
因为范围最大是100， 所以最大值给100

  1. softPwmWrite(LED_R, 10);
  2. softPwmWrite(LED_G, 100);
  3. softPwmWrite(LED_R, 50);

5. 整体逻辑

使用一个now变量， 记录当前是哪个颜色
image.png
1 代表 红色
2 代表 绿色
3 代表 蓝色
初始值是1

5.1 颜色增加/ 减小槽函数

按钮1 是颜色增加的槽函数，首先判断当前是哪个按键，如果当前是4， 要跳回1
如果到最亮，啥都不干，不设置softPwm

  1. void MainWindow::ReadKey1(){
  2.     if(!isClicked(KEY1)){
  3.         return;
  4.     }
  5.     qDebug() << "key1 clicked";
  7.     // 如果now变成了4 说明要回到1
  8.     if(now == 4) now =1;
  9.     switch (now) {
  10.         case 1:{
  11.             if(red_value==100){
  12.                 break; // 到达最亮
  13.             }
  14.             red_value += 10;
  15.             softPwmWrite(LED_R, red_value);
  16.             break;
  17.         }
  19.         case 2:{
  20.             if(green_value==100){
  21.                 break; // 到达最亮
  22.             }
  23.             green_value += 10;
  24.             softPwmWrite(LED_G, green_value);
  25.             break;
  26.         }
  28.         case 3:{
  29.             if(blue_value==100){
  30.                 break; // 到达最亮
  31.             }
  32.             blue_value += 10;
  33.             softPwmWrite(LED_B, blue_value);
  34.             break;
  35.         }
  37.     }
  38. }

按钮2 是颜色减少的槽函数，首先判断当前是哪个按键，如果当前是4， 要跳回1
如果到最暗，啥都不干，不设置softPwm

  1. void MainWindow::ReadKey2(){
  2.     if(!isClicked(KEY2)){
  3.         return;
  4.     }
  5.     qDebug() << "key2 clicked";
  7.     qDebug() << "key1 clicked";
  8.     if(now == 4) now = 1;
  9.     switch (now) {
  10.         case 1:{
  11.             if(red_value==0){
  12.                 break;
  13.             }
  14.             red_value -= 10;
  15.             softPwmWrite(LED_R, red_value);
  16.             break;
  17.         }
  19.         case 2:{
  20.             if(green_value==0){
  21.                 break;
  22.             }
  23.             green_value -= 10;
  24.             softPwmWrite(LED_G, green_value);
  25.             break;
  26.         }
  28.         case 3:{
  29.             if(blue_value==0){
  30.                 break;
  31.             }
  32.             blue_value -= 10;
  33.             softPwmWrite(LED_B, blue_value);
  34.             break;
  35.         }
  37.     }
  38. }

5.3 确认槽函数

将 now + 1

  1. void MainWindow::ReadKey3(){
  2.     if(!isClicked(KEY3)){
  3.         return;
  4.     }
  5.     qDebug() << "key3 clicked";
  6.     now++;
  7. }

6. GUI绑定

思路1：

  • 3个文本框， 可以设置和查看颜色分量
  • 一个确定按钮，设置颜色
  • 一个文本框，显示当前按钮的状态

image.png


7. 完整代码

头文件

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  4. #define KEY1 21
  5. #define KEY2 07
  6. #define KEY3 06
  8. #define LED_R 28
  9. #define LED_G 29
  10. #define LED_B 27
  11. #define PERIOD 50
  14. #include <QMainWindow>
  15. #include <QTimer>
  17. namespace Ui {
  18. class MainWindow;
  19. }
  21. class MainWindow : public QMainWindow
  22. {
  23.     Q_OBJECT
  25. public:
  26.     explicit MainWindow(QWidget *parent = nullptr);
  27.     ~MainWindow();
  28.     QTimer *timer;
  30.     QTimer *led_r_timer;
  31.     QTimer *led_g_timer;
  32.     QTimer *led_b_timer;
  34. private:
  35.     Ui::MainWindow *ui;
  36.     bool isClicked(int pin);
  37.     int red_value;
  38.     int blue_value;
  39.     int green_value;
  41.     int now;
  43. private slots:
  44.     void ReadKey1();
  45.     void ReadKey2();
  46.     void ReadKey3();
  49. };
  51. #endif // MAINWINDOW_H

cpp 文件

  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include "wiringPi.h"
  4. #include "softPwm.h"
  5. #include <QDebug>
  8. MainWindow::MainWindow(QWidget *parent) :
  9.     QMainWindow(parent),
  10.     ui(new Ui::MainWindow)
  11. {
  12.     ui->setupUi(this);
  13.     wiringPiSetup();
  15.     // init pin of keys
  16.     pinMode(KEY1, INPUT);
  17.     pinMode(KEY2, INPUT);
  18.     pinMode(KEY3, INPUT);
  19.     // set defalut mode is high
  20.     pullUpDnControl(KEY1, PUD_UP);
  21.     pullUpDnControl(KEY2, PUD_UP);
  22.     pullUpDnControl(KEY3, PUD_UP);
  24.     // init pin of led
  25.     softPwmCreate(LED_R, 0, 100);
  26.     softPwmCreate(LED_G, 0, 100);
  27.     softPwmCreate(LED_B, 0, 100);
  29.     //Init timer
  30.     timer = new QTimer;
  31.     connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey1()));
  32.     connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey2()));
  33.     connect(timer, SIGNAL(timeout()), this, SLOT(ReadKey3()));
  34.     timer->start(50);
  36.     red_value = 0;
  37.     green_value = 0;
  38.     blue_value = 0;
  40.     now = 1;
  42.     softPwmWrite(LED_R, 0);
  43.     softPwmWrite(LED_G, 0);
  44.     softPwmWrite(LED_B, 0);
  46. }
  48. MainWindow::~MainWindow()
  49. {
  50.     delete ui;
  51.     if(timer->isActive()){
  52.         timer->stop();
  53.     }
  54.     delete timer;
  55. }
  57. bool MainWindow::isClicked(int pin){
  58.     if(digitalRead(pin) == 0){
  59.         delay(20);
  60.         if(digitalRead(pin) == 0){
  61.             while (digitalRead(pin) == 0);
  62.             return true;
  63.         }
  64.     }
  65.     return false;
  66. }
  68. void MainWindow::ReadKey1(){
  69.     if(!isClicked(KEY1)){
  70.         return;
  71.     }
  72.     qDebug() << "key1 clicked";
  73.     if(now == 4) now =1;
  74.     switch (now) {
  75.         case 1:{
  76.             if(red_value==100){
  77.                 break;
  78.             }
  79.             red_value += 10;
  80.             softPwmWrite(LED_R, red_value);
  81.             break;
  82.         }
  84.         case 2:{
  85.             if(green_value==100){
  86.                 break;
  87.             }
  88.             green_value += 10;
  89.             softPwmWrite(LED_G, green_value);
  90.             break;
  91.         }
  93.         case 3:{
  94.             if(blue_value==100){
  95.                 break;
  96.             }
  97.             blue_value += 10;
  98.             softPwmWrite(LED_B, blue_value);
  99.             break;
  100.         }
  102.     }
  103. }
  105. void MainWindow::ReadKey2(){
  106.     if(!isClicked(KEY2)){
  107.         return;
  108.     }
  109.     qDebug() << "key2 clicked";
  111.     qDebug() << "key1 clicked";
  112.     if(now == -1) now =3;
  113.     switch (now) {
  114.         case 1:{
  115.             if(red_value==0){
  116.                 break;
  117.             }
  118.             red_value -= 10;
  119.             softPwmWrite(LED_R, red_value);
  120.             break;
  121.         }
  123.         case 2:{
  124.             if(green_value==0){
  125.                 break;
  126.             }
  127.             green_value -= 10;
  128.             softPwmWrite(LED_G, green_value);
  129.             break;
  130.         }
  132.         case 3:{
  133.             if(blue_value==0){
  134.                 break;
  135.             }
  136.             blue_value -= 10;
  137.             softPwmWrite(LED_B, blue_value);
  138.             break;
  139.         }
  141.     }
  143. }
  145. void MainWindow::ReadKey3(){
  146.     if(!isClicked(KEY3)){
  147.         return;
  148.     }
  149.     qDebug() << "key3 clicked";
  150.     now++;
  151. }