QML访问C++对象驱动飞行仪表

已于 2022-10-28 16:58:57 修改
阅读量430 收藏 6
点赞数
分类专栏： QML 文章标签： qt c++
于 2022-10-28 16:56:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shouqw/article/details/127574109
版权

文章目录

引入

在上篇文章基于QML的飞行仪表中，从GitHub上搬下来几个基于QML的飞行仪表，但只是绘制出来，并不会动。今天通过C++对象访问的方式把他们驱动起来。
实际上，原项目也是这么做的，这里参考其C++类，并做了一些改动。

QML访问C++对象

在之前的文章中曾提到过QML与C++交互的方法，用到了将C++类名注册到QML，并在QML实体化然后使用的方式。今天我们换个方式实现，在C++中先定义类并实体化，然后使用QML访问C++对象。
C++类的定义其实没有什么区别，QML要想访问C++对象的方法，要使用Q_INVOKABLE、Q_PROPERTY宏等。
访问C++对象，需要先注册该对象
QQmlApplicationEngine::rootContext()->setContextProperty（）
然后就可以在QML中直接访问C++对象了

C++类

在工程上右键添加类，类必须继承 QObject ，并包含QObject。直接上源码

#ifndef FLIGHTDATA_H
#define FLIGHTDATA_H

#include <QObject>
#include <QTimer>

class FlightData : public QObject
{
    Q_OBJECT
public:
    explicit FlightData(QObject *parent = nullptr);

    double roll() const;
    void setRoll(double newroll);

    double pitch() const;
    void setPitch(double newpitch);

    double heading() const;
    void setHeading(double newheading);

    double slipSkid() const;
    void setSlipSkid(double newslipskid);

    double turnRate() const;
    void setTurnRate(double newturnrate);

    double airspeed() const;
    void setAirspeed(double newairspeed);

    double pressure() const;
    void setPressure(double newpressure);

    double altitude() const;
    void setAltitude(double newaltitude);

    double climbRate() const;
    void setClimbRate(double newclimbrate);

    Q_INVOKABLE void anim_Start();
    Q_INVOKABLE void anim_Stop();


signals:
    void rollChanged();
    void pitchChanged();
    void headingChanged();
    void slipSkidChanged();
    void turnRateChanged();
    void airspeedChanged();
    void pressureChanged();
    void altitudeChanged();
    void climbRateChanged();

private:

    double m_roll;
    double m_pitch;
    double m_heading;
    double m_slipskid;
    double m_turnrate;
    double m_airspeed;
    double m_pressure;
    double m_altitude;
    double m_climbrate;

    QTimer mTimer;
    int frame;
    void update();

    Q_PROPERTY(double roll READ roll WRITE setRoll NOTIFY rollChanged);
    Q_PROPERTY(double pitch READ pitch WRITE setPitch NOTIFY pitchChanged);
    Q_PROPERTY(double heading READ heading WRITE setHeading NOTIFY headingChanged);
    Q_PROPERTY(double slipSkid READ slipSkid WRITE setSlipSkid NOTIFY slipSkidChanged);
    Q_PROPERTY(double turnRate READ turnRate WRITE setTurnRate NOTIFY turnRateChanged);
    Q_PROPERTY(double airspeed READ airspeed WRITE setAirspeed NOTIFY airspeedChanged);
    Q_PROPERTY(double pressure READ pressure WRITE setPressure NOTIFY pressureChanged);
    Q_PROPERTY(double altitude READ altitude WRITE setAltitude NOTIFY altitudeChanged);
    Q_PROPERTY(double climbRate READ climbRate WRITE setClimbRate NOTIFY climbRateChanged);


};

#endif // FLIGHTDATA_H

C++类的实现

#include "flightdata.h"
#include <cmath>

FlightData::FlightData(QObject *parent)
    : QObject{parent}
{
    m_roll = 0;
    m_pitch = 0;
    m_heading = 0;
    m_slipskid = 0;
    m_turnrate = 0;
    m_airspeed = 0;
    m_pressure = 0;
    m_altitude = 0;
    m_climbrate = 0;

    frame = 0;

    connect(&mTimer,&QTimer::timeout,this,&FlightData::update);

}

double FlightData::roll() const{
    return m_roll;
}

void FlightData::setRoll(double newroll){
    if (std::isnan(newroll) || qFuzzyCompare(m_roll, newroll))
           return;

    if (newroll < -180)
        newroll = -180;
    else if (newroll > 180)
        newroll = 180;

    m_roll = newroll;
    emit rollChanged();
}

double FlightData::pitch() const{
    return m_pitch;
}

void FlightData::setPitch(double newpitch){
    if (std::isnan(newpitch) || qFuzzyCompare(m_pitch, newpitch))
           return;

    if (newpitch < -90)
        newpitch = -90;
    else if (newpitch > 90)
        newpitch = 90;

    m_pitch = newpitch;
    emit pitchChanged();
}

double FlightData::heading() const{
    return m_heading;
}

void FlightData::setHeading(double newheading){
    if (std::isnan(newheading) || qFuzzyCompare(m_heading, newheading))
           return;

    while (newheading < 0.0)
        newheading += 360.0;
    while (newheading > 360.0)
        newheading -= 360.0;

    m_heading = newheading;
    emit headingChanged();
}

double FlightData::slipSkid() const{
    return m_slipskid;
}

void FlightData::setSlipSkid(double newslipskid){
    if (std::isnan(newslipskid) || qFuzzyCompare(m_slipskid, newslipskid))
           return;
    if (newslipskid < -15)
        newslipskid = -15;
    else if (newslipskid > 15)
        newslipskid = 15;

    m_slipskid = newslipskid;
    emit slipSkidChanged();
}

double FlightData::turnRate() const{
    return m_turnrate;
}

void FlightData::setTurnRate(double newturnrate){
    if (std::isnan(newturnrate) || qFuzzyCompare(m_turnrate, newturnrate))
           return;
    if (newturnrate < -6)
         newturnrate = -6;
     else if (newturnrate > 6)
         newturnrate = 6;

    m_turnrate = newturnrate;
    emit turnRateChanged();
}

double FlightData::airspeed() const{
    return m_airspeed;
}

void FlightData::setAirspeed(double newairspeed){
    if (std::isnan(newairspeed) || qFuzzyCompare(m_airspeed, newairspeed))
           return;

    if (newairspeed < 0)
        newairspeed = 0;
    else if (newairspeed > 9999)
        newairspeed = 9999;

    m_airspeed = newairspeed;
    emit airspeedChanged();
}

double FlightData::pressure() const{
    return m_pressure;
}

void FlightData::setPressure(double newpressure){
    if (std::isnan(newpressure) || qFuzzyCompare(m_pressure, newpressure))
           return;

    if (newpressure < 0)
        newpressure = 0;
    else if (newpressure > 2000)
        newpressure = 2000;

    m_pressure = newpressure;
    emit pressureChanged();
}

double FlightData::altitude() const{
    return m_altitude;
}

void FlightData::setAltitude(double newaltitude){
    if (std::isnan(newaltitude) || qFuzzyCompare(m_altitude, newaltitude))
           return;
    if (newaltitude < 0)
        newaltitude = 0;
    else if (newaltitude > 99999)
        newaltitude = 99999;

    m_altitude = newaltitude;
    emit altitudeChanged();
}

double FlightData::climbRate() const{
    return m_climbrate;
}

void FlightData::setClimbRate(double newclimbrate){
    if (std::isnan(newclimbrate) || qFuzzyCompare(m_altitude, newclimbrate))
           return;

    if (newclimbrate > 20)
        newclimbrate = 20;
    else if (newclimbrate < -20)
        newclimbrate = -20;

    m_climbrate = newclimbrate;
    emit climbRateChanged();
}

void FlightData::anim_Start(){

    mTimer.start(100);
    frame = 0;
}

void FlightData::anim_Stop(){

    if(mTimer.isActive())
        mTimer.stop();

    frame = 0;
}

void FlightData::update(){

    double newroll = 90.0 * sin(M_PI*frame*0.01);
    double newpitch = 60.0 * sin(0.5*M_PI*frame*0.01);
    double newheading = 180.0 * sin(M_PI*frame*0.01) ;
    double newslipskid = 15.0 * sin(2*M_PI*frame*0.01);
    double newturnrate =  6.0 * sin(1*M_PI*frame*0.01 + M_PI/2.0);
    double newairspeed = 120 * sin(M_PI*frame*0.01) + 120.0;
    double newmpressure = 1.75 * sin(M_PI*frame*0.01) + 29.75;
    double newaltitude = 15000 * sin(0.5*M_PI*frame*0.01) + 15000;
    double newclimbrate = 20.0 * sin(2*M_PI*frame*0.01) ;
    frame++;
    setRoll(newroll);
    setPitch(newpitch);
    setHeading(newheading);
    setTurnRate(newturnrate);
    setSlipSkid(newslipskid);
    setAirspeed(newairspeed);
    setPressure(newmpressure);
    setAltitude(newaltitude);
    setClimbRate(newclimbrate);

}

使用了一个定时器，定时触发更新飞行数据。

QML文件

加入访问C++对象的部分，这里访问C++对象的几个函数。

import "sixbasic"
import QtQuick 2.15
import QtQuick.Window 2.15
import QtQuick.Layouts 1.3
import QtQuick.Controls 2.0

Window {
    minimumWidth: 800
    minimumHeight: 700
    title: "Basic Six"
    color: "#ffffff"
    visible: true
    id:root

    GridLayout{
        columns: 3
        id:meter
        width: parent.width*0.9

        anchors
        {
            fill:parent

            margins: 16
        }

        Item {
            Layout.fillWidth: true
            Layout.fillHeight: true
            id: it_asi

            AirspeedIndicator {
                radius: 0.5 * Math.min(parent.width, parent.height)
                id:myasi
                airspeed: pfd.airspeed

            }
        }

        Item {
            Layout.fillWidth: true
            Layout.fillHeight: true

            AttitudeIndicator{
                radius: 0.5 * Math.min(parent.width,parent.height)
                id: myai

                roll: pfd.roll
                pitch: pfd.pitch
            }
        }

        Item {
            Layout.fillHeight: true
            Layout.fillWidth: true
            id:it_alt

        Altimeter{
            radius: 0.5 * Math.min(parent.width, parent.height)
            id: myalt
            altitude: pfd.altitude
            pressure: pfd.pressure
            }
        }

        Item{
            Layout.fillWidth: true
            Layout.fillHeight: true

            TurnCoordinator {
                radius: 0.5 * Math.min(parent.width, parent.height)
                id: mytc
                turnRate: pfd.turnRate
                slipSkid: pfd.slipSkid
            }
        }


        Item {
            Layout.fillWidth: true
            Layout.fillHeight: true

            HeadingIndicator {
                radius: 0.5 * Math.min(parent.width, parent.height)
                id: myheading
                heading: pfd.heading
            }
        }

        Item {
            Layout.fillWidth: true
            Layout.fillHeight: true

            VerticalSpeedIndicator {
                radius: 0.5 * Math.min(parent.width, parent.height)
                id: myvsi
                climbRate: pfd.climbRate
            }
        }

//       Slider{
//           id: airspeed_ctl
//           anchors.left: myasi.it_asi
//           width: myasi.width
//           from: 0
//           to: 240
//           stepSize: 0.1
           Connections{
               target:myai
               onValueChanged:{
                   myai.airspeed = airspeed_ctl.value
               }
//           onValueChanged: {
//               myasi.airspeed = value
//           }

//       }

//       Slider{
//           id: roll_ctl
//           anchors.left: myai.left
//           width: myai.width
//           from: -180
//           to: 180
//           stepSize: 1
           onValueChanged: {
               myai.roll = value
           }
//       }

//       Slider{
//           id: pitch_ctl
//           anchors.left: myalt.left
//           width: myalt.width

//           from: -30
//           to: 30
//           stepSize: 0.1
           onValueChanged: {
               myai.pitch = value
           }
//       }

//       Slider{
//           id: altitude_ctl
//           anchors.left: myasi.it_asi
//           width: myasi.width

//           from: 0
//           to: 10000
//           stepSize: 1
           onValueChanged: {
               myalt.altitude = value
           }
//       }

//       Slider{
//           id: pressure_ctl
//           anchors.left: myai.left
//           width: myai.width

//           from: 28
//           to: 31.6
//           stepSize: 0.1
           onValueChanged: {
               myalt.pressure = value
           }
//       }

//       Slider{
//           id: heading_ctl
//           anchors.left: myalt.left
//           width: myalt.width
//           from: 0
//           to: 360
//           stepSize: 0.1
//           onValueChanged: {
//               myheading.heading = value
//           }
//       }


//       Slider{
//           id: turnrate_ctl
//           anchors.left: myasi.it_asi
//           width: myasi.width

//           from: -6
//           to: 6
//           stepSize: 0.1
//           onValueChanged: {
//               mytc.turnRate = value
//           }
//       }

//       Slider{
//           id: slipskid_ctl
//           anchors.left: myai.left
//           width: myai.width
//           from: -15
//           to: 15
//           stepSize: 0.1
//           onValueChanged: {
//               mytc.slipSkid = value
//           }
//       }

//       Slider{
//           id: verticalspd_ctl
//           anchors.left: myalt.left
//           width: myalt.width

//           from: -20
//           to: 20
//           stepSize: 0.1
           onValueChanged: {
               myvsi.climbRate = value
           }
//       }


            Button{
            id:btn
            text: qsTr("Sim_Start")
            font{
                pixelSize: 16
                family: "Times"
                bold: true
            }

            background:Rectangle{
                id: btnbg
                color: "green"
                }


            Layout.fillWidth: false
            Layout.fillHeight: false
            Layout.columnSpan: 3
            Layout.rowSpan: 1
            Layout.column:0
            Layout.row:2

            Layout.alignment: Qt.AlignHCenter

            onClicked: {
               if(btn.text == "Sim_Start")
               {
                   pfd.anim_Start()
                   btn.text = "Sim_Stop"
                   btnbg.color = "orange"
               }
               else if(btn.text == "Sim_Stop")
               {
                   pfd.anim_Stop()
                   btn.text = "Sim_Start"
                   btnbg.color = "green"
               }
             }
          }



//       Button{
//          width: parent.width*0.4
          anchors.left: start.left + 500
//          visible: false
//       }



//       Button{
//           text: qsTr("Anim_Stop")
//           width: root.width*0.3
//           Layout.columnSpan: 3
//           Layout.column:1
//           Layout.row:3

//           onClicked: {
//               pfd.anim_Stop()
//           }
//       }

    }

}

控件布局还不理想，还需要研究优化😟

Main函数

将C++对象注册到QML即可。

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "flightdata.h"

int main(int argc, char *argv[])
{
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
#endif
    QGuiApplication app(argc, argv);

    QQmlApplicationEngine engine;
    const QUrl url(QStringLiteral("qrc:/main.qml"));
    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
                     &app, [url](QObject *obj, const QUrl &objUrl) {
        if (!obj && url == objUrl)
            QCoreApplication::exit(-1);
    }, Qt::QueuedConnection);
    FlightData *pfd = new FlightData();

    engine.rootContext()->setContextProperty("pfd", pfd);
    engine.load(url);

    return app.exec();
}

运行结果

在这里插入图片描述

MSh_I
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
QT通过QQuickWidget与QML之间的交互及实现(类似)仪表盘
QtCompany的博客
04-21 919
1、在与qml通信的时候，需要把函数接口暴露给qml需要在函数前面加入Q_INVOKABLE关键字，且需要注意成员函数的公有或私有类型。QT通过QQuickWidget与QML之间的交互及实现(类似)仪表盘-QT开发中文网。QT通过QQuickWidget与QML之间的交互及实现(类似)仪表盘。2、利用quickWidget来进行数据传递。
基于QML的飞行仪表
shouqw的博客
10-24 2054
搬来GitHub上一个基于QML的飞行仪表项目
qml绘制仪表盘控件
t01051的博客
07-22 4621
刚开始上手qt，说实话迷得很啊。。。 不过qt做的界面是真的漂亮，之前在b站看qt官方发布的一些视频，仪表盘是真的好看 今天倒腾了一天，用qml绘制了一个简单的汽车仪表控件，趁现在还热着，先记下来 新建一个空的qml工程 创建工程的时候要注意，工程路径中不能有中文，否则会导致编译失败 创建完成后按例编译运行，确保工程能正常编译，否则等写得差不多却发现无法正常编译那就很尴尬了。。。 再添加一个单独的.qml文件，我们在里面编写自定义的控件，这样在别的工程中只要载入这个qml文件就能
C++实现显示(监视)器复制显示
04-20 3045
Windows实现多显示器的显示配置，热插拔监控
基于MFC C++设置进程运行显示器
baidu_39123902的博客
06-30 617
最近遇到项目，需要在单台电脑上运行两次同一个.exe文件（基于对话框），但两个进程需要在不同的屏幕上显示。在网上查找了一些资料，要么付费，要么代码中有一定问题。综合各个资料后，整理出可以直接使用的代码。既是为了做笔记，也是将经验分享给大家。 实现该功能的API为 EnumDisplayDevices()和EnumDisplaySettings()。对于这两个函数中的各个参数，网上已经有很详细的解释，在这里不在赘述，直接上代码。 //使用到的头文件和使用命名空间 #include <iostream&g
QML 与 C++交互 - 01QML访问C++属性
08-21
本文将详细介绍如何在QML中访问C++的属性。 首先，要使QML能够访问C++对象，需要将C++类注册为QML类型。这通常通过`qmlRegisterType`宏来完成，该宏将C++类注册到QML引擎中，使其可以在QML脚本中使用。例如： ```...
QML与C++交互QML与C++交互
03-16
QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++交互QML与C++...
QML与C++对象间的互操作：工程Demo
10-24
在实际项目开发中，经常需要将两者结合，实现QML与C++对象间的互操作，以充分利用各自的优势。本工程Demo就展示了这种交互方式。 首先，我们需要理解QML引擎如何与C++世界连接。Qt的QQmlEngine和QQmlContext是关键...
QML 调用 C++对象类型属性示例
05-29
在QML文件中，可以像访问任何其他QML属性一样，直接使用`cppObject`来访问C++对象。假设我们有一个QML组件，我们可以这样读取或修改`myProperty`： ```qml import QtQuick 2.0 Rectangle { width: 300; ...
QT6实战-QML与C++联合编程
最新发布
05-14
Qt是1991年由HaavardNord和EirikChambe-Eng开发的跨平台C++图形用户界面应用程序开发框架。发展至今，它既可以开发GUI程序，也可以开发非GUI程序，比如控制台工具和服务器。Qt是一个跨平台的C++应用程序框架，支持...
汽车仪表盘Qt demo
10-16
基于Qt5.6.2的汽车仪表盘demo，QML语法。功能界面有随机时速表和转速表，左转向灯
opengl_飞机虚拟仪表盘界面程序_c++代码
03-09
一个使用c++编写的，基于opengl的一个简单的飞机虚拟仪表盘界面程序。仿照波音747做的。仅供学习参考。
CuteBoard：实时仪表板（Qt）
02-05
可爱板 实时仪表盘（Qt） 实时可视化 版
C++编写电压电流表仪表盘
10-12
此源码是利用C++在vs2008环境下编写，经测试运行成功。
C++仪表示例.zip
10-21
C++表盘程序
win10 C++ 飞行模式
qq_40923160的博客
05-28 380
#include <Windows.h> #include <assert.h> #include <stdio.h> static GUID const CLSID_RadioManagementAPI = { 0x581333f6, 0x28db, 0x41be, { 0xbc, 0x7a, 0xff, 0x20, 0x1f, 0x12, 0xf3, 0xf6 } }; static GUID const CID_IRadioManager = { 0xdb3afb
[QML开发笔记]-QML绘制仪表盘属性设置
Qt自定义控件及应用开发
04-24 955
[QML开发笔记]-QML绘制仪表盘属性设置 在[QML开发笔记]-QML绘制仪表盘介绍了使用QML绘制仪表盘的方法，在此基础上增加属性设置，动态改变属性，同样通过creator也可以设置相应属性。 效果： ...
QML中圆形进度仪表盘控件的使用
Shado_walker的专栏
06-14 6328
在之前的文章中，有一篇介绍了在QML中制作自定义圆形进度条的文章，在那篇文章中，主要是写了如何在QML的Canvas上使用2D进行绘图。同样是圆形进度条，在这篇文章中，主要介绍QML自己原生的一个圆形仪表盘的使用，其中的主体结构都是QML自己实现的，我们自己只需要根据需要，设置我们想要的样式和属性值，即可达到理想中仪表盘的效果，省去了我们自己绘制界面的过程，是一个很好的控件，希望能够帮助到需要自己
用源码实现QML显示LCD数字
yangxueyangxue的博客
06-21 1351
在上一遍文章介绍加载字体库来实现LCD显示数字，本篇介绍使用源码来实现，动手自己写源码。在UI下QLCDNumber控件实现了LCD数字显示，观看该控件的源码，实现自己的LCD数字显示。首先定义一个类，例如“LCDNumberItem”继承QQuickPaintedItem类。h文件如下所示：主要是仿照QLCDNumber控件#ifndef LCDNUMBERITEM_H#define LCDNU...
qml访问C++结构体
05-30
在 QML 中，可以通过下面的步骤访问 C++ 中的结构体： 1. 在 C++ 中定义一个结构体，例如： ``` struct MyStruct { int x; int y; }; ``` 2. 将结构体作为一个属性添加到 QML 中，例如： ``` Q_PROPERTY...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值