Kart  1.1
BTS SN-IR La Salle Avignon 2018
Connecteurs publics | Fonctions membres publiques | Fonctions membres privées | Attributs privés
Référence de la classe IHMKart

Fenêtre principale de l'application. Plus de détails...

#include <ihmkart.h>

Graphe de collaboration de IHMKart:
Collaboration graph
[légende]

Liste de tous les membres

Connecteurs publics

void rafraichir (Echantillon echantillon)
 Slot gérant l'affichage des données reçues.
void demarrerEssai ()
 Permet à un opérarteur de démarrer un essai pour un kart.
void arreterEssai ()

Fonctions membres publiques

 IHMKart (QWidget *parent=0)
 Constructeur de la classe fenêtre principale.
 ~IHMKart ()
 Destructeur.

Fonctions membres privées

void chargerIDKarts ()
void chargerIDOperateurs ()
void initialiserIHM ()
void initialiserQWT ()
void afficherDonneesTelemetrie (Echantillon echantillon)
 Affichage des données reçues.
void afficherGraphiques (Echantillon echantillon)
 Affichage des graphiques.
void reinitialiserGraphiques ()

Attributs privés

Ui::IHMKart * ui
Communicationcommunication
Telemetrie telemetrie
QString idKart
QString idOperateur
QwtPlotCurve * courbeVitesse
QwtPlotCurve * courbeTension
QwtPlotCurve * courbeCourant
QwtPlotCurve * courbeTemperature
QwtPlotCurve * courbeChargeBatterie
Courbe vitesse
Courbe tension
Courbe courant
Courbe temperature
Courbe chargeBatterie

Description détaillée

Auteur:
Penne Florent
Version:
0.9

Documentation des constructeurs et destructeur

IHMKart::IHMKart ( QWidget *  parent = 0) [explicit]
Paramètres:
parentQObject l'adresse de l'objet Qt parent (par défaut 0 pour la fenêtre principale)

Références arreterEssai(), chargerIDKarts(), chargerIDOperateurs(), communication, demarrerEssai(), initialiserIHM(), initialiserQWT(), rafraichir(), et ui.

                                :
    QMainWindow(parent),
    ui(new Ui::IHMKart)
{
    initialiserIHM();
    initialiserQWT();

    chargerIDKarts();

    chargerIDOperateurs();

    communication = new Communication(this);

    connect(ui->bDemarrageEssai, SIGNAL(clicked()), this, SLOT(demarrerEssai()));
    connect(ui->bArretEssai, SIGNAL(clicked()), this, SLOT(arreterEssai()));
    connect(communication, SIGNAL(nouvelEchantillon(Echantillon)), this, SLOT(rafraichir(Echantillon)));
}

Références ui.

{
    delete ui;
}

Documentation des fonctions membres

void IHMKart::afficherDonneesTelemetrie ( Echantillon  echantillon) [private]
Paramètres:
echantillon

Références Echantillon::chargeBatterie, Echantillon::courantBatterie, Echantillon::horodatage, Echantillon::temperatureMoteur, Echantillon::tensionBatterie, ui, et Echantillon::vitesse.

Référencé par rafraichir().

{
    ui->lcdTension->display(echantillon.tensionBatterie);
    ui->lcdCourant->display(echantillon.courantBatterie);
    ui->lcdCharge->display(echantillon.chargeBatterie);
    ui->lcdVitesse->display(echantillon.vitesse);
    ui->lcdTemperature->display(echantillon.temperatureMoteur);
    qDebug() << Q_FUNC_INFO << echantillon.horodatage.toString("dd/MM/yyyy hh:mm");
}
void IHMKart::afficherGraphiques ( Echantillon  echantillon) [private]
Paramètres:
echantillon
A faire:
réaliser l'affichage des graphiques pour la charge, tension et courant

Références Echantillon::chargeBatterie, chargeBatterie, courant, Echantillon::courantBatterie, courbeChargeBatterie, courbeCourant, courbeTemperature, courbeTension, courbeVitesse, temperature, Echantillon::temperatureMoteur, tension, Echantillon::tensionBatterie, ui, Echantillon::vitesse, vitesse, Courbe::x, et Courbe::y.

Référencé par rafraichir().

{
    QTime maintenant = QTime::currentTime();
    int seconde = maintenant.second();

    if(seconde == 0)
    {
        // on efface les tracés précédents
        vitesse.x.clear();
        vitesse.y.clear();
        courbeVitesse->setSamples(vitesse.x, vitesse.y);
        ui->qwtGraphiqueVitesse->replot();

        tension.x.clear();
        tension.y.clear();
        courbeTension->setSamples(tension.x, tension.y);
        ui->qwtGraphiqueTension->replot();

        courant.x.clear();
        courant.y.clear();
        courbeCourant->setSamples(courant.x, courant.y);
        ui->qwtGraphiqueCourant->replot();

        temperature.x.clear();
        temperature.y.clear();
        courbeTemperature->setSamples(temperature.x, temperature.y);
        ui->qwtGraphiqueTemperature->replot();

        chargeBatterie.x.clear();
        chargeBatterie.y.clear();
        courbeChargeBatterie->setSamples(chargeBatterie.x, chargeBatterie.y);
        ui->qwtGraphiqueChargeBatterie->replot();
    }

    // on ajoute les mesures
    vitesse.x.push_back((double)seconde);
    vitesse.y.push_back((double)echantillon.vitesse);

    tension.x.push_back((double)seconde);
    tension.y.push_back((double)echantillon.tensionBatterie);

    courant.x.push_back((double)seconde);
    courant.y.push_back((double)echantillon.courantBatterie);

    temperature.x.push_back((double)seconde);
    temperature.y.push_back((double)echantillon.temperatureMoteur);

    chargeBatterie.x.push_back((double)seconde);
    chargeBatterie.y.push_back((double)echantillon.chargeBatterie);






    // on trace les points x,y
    courbeVitesse->setSamples(vitesse.x, vitesse.y);
    ui->qwtGraphiqueVitesse->replot();

    courbeTension->setSamples(tension.x, tension.y);
    ui->qwtGraphiqueTension->replot();

    courbeCourant->setSamples(courant.x, courant.y);
    ui->qwtGraphiqueCourant->replot();

    courbeTemperature->setSamples(temperature.x, temperature.y);
    ui->qwtGraphiqueTemperature->replot();

    courbeChargeBatterie->setSamples(chargeBatterie.x, chargeBatterie.y);
    ui->qwtGraphiqueChargeBatterie->replot();




}
A faire:
exporter les données télémétriques au format CSV

Références communication, idKart, Communication::setIdKart(), et ui.

Référencé par IHMKart().

{
    // Démarre la collecte des données pour l'id kart
    communication->setIdKart(QString(""));
    ui->statusBar->showMessage(QString::fromUtf8("Arrêt de l'essai pour le kart %1").arg(idKart));

    ui->listeIDKarts->setEnabled(true);
    ui->listeIDOperateurs->setEnabled(true);
    ui->bDemarrageEssai->setEnabled(true);
    ui->bArretEssai->setEnabled(false);

}
void IHMKart::chargerIDKarts ( ) [private]
A faire:
lire les ID kart dans le fichier xml et charger la liste

Références ui.

Référencé par IHMKart().

{
    for(int i = 5001; i < 5004; i++)
    {
        ui->listeIDKarts->addItem(QString("%1").arg(i));
    }
}
void IHMKart::chargerIDOperateurs ( ) [private]
A faire:
lire les ID opérateur dans le fichier xml et charger la liste

Références ui.

Référencé par IHMKart().

{
    for(int i = 101; i < 103; i++)
    {
        ui->listeIDOperateurs->addItem(QString("%1").arg(i));
    }
}

Références communication, idKart, reinitialiserGraphiques(), Communication::setIdKart(), Telemetrie::supprimerEchantillons(), telemetrie, et ui.

Référencé par IHMKart().

{
    ui->listeIDKarts->setEnabled(false);
    ui->listeIDOperateurs->setEnabled(false);
    ui->bDemarrageEssai->setEnabled(false);
    ui->bArretEssai->setEnabled(true);

    // Démarre la collecte des données pour l'id kart
    idKart = ui->listeIDKarts->currentText();
    telemetrie.supprimerEchantillons();
    communication->setIdKart(idKart);
    ui->statusBar->showMessage(QString::fromUtf8("Démarrage de l'essai pour le kart %1").arg(idKart));

    ui->lcdTension->display(0);
    ui->lcdCourant->display(0);
    ui->lcdCharge->display(0);
    ui->lcdVitesse->display(0);
    ui->lcdTemperature->display(0);
    reinitialiserGraphiques();
}
void IHMKart::initialiserIHM ( ) [private]

Références ui.

Référencé par IHMKart().

{
    ui->setupUi(this);
    ui->bDemarrageEssai->setEnabled(true);
    ui->bArretEssai->setEnabled(false);

    // Affichage de la page d'accueil
    ui->tabWidget->setCurrentIndex(0);
}
void IHMKart::initialiserQWT ( ) [private]
A faire:
initialiser les autres graphiques (charge, tension et courant)

Références courbeChargeBatterie, courbeCourant, courbeTemperature, courbeTension, courbeVitesse, et ui.

Référencé par IHMKart().

{
    QwtPlotGrid *grid;

    // Un titre
    ui->qwtGraphiqueVitesse->setTitle(QString::fromUtf8("Vitesse"));
    ui->qwtGraphiqueTension->setTitle(QString::fromUtf8("Tension"));
    ui->qwtGraphiqueCourant->setTitle(QString::fromUtf8("Courant"));
    ui->qwtGraphiqueTemperature->setTitle(QString::fromUtf8("Temperature"));
    ui->qwtGraphiqueChargeBatterie->setTitle(QString::fromUtf8("% Batterie"));


    // une légende à droite
    ui->qwtGraphiqueVitesse->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    ui->qwtGraphiqueTension->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    ui->qwtGraphiqueCourant->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    ui->qwtGraphiqueTemperature->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    ui->qwtGraphiqueChargeBatterie->insertLegend(new QwtLegend(), QwtPlot::RightLegend);

    // cadrillage
    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ui->qwtGraphiqueVitesse);

    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ui->qwtGraphiqueTension);

    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ui->qwtGraphiqueCourant);

    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ui->qwtGraphiqueTemperature);

    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ui->qwtGraphiqueChargeBatterie);



    // configuration des axes
    ui->qwtGraphiqueVitesse->setAxisTitle(ui->qwtGraphiqueVitesse->xBottom, QString::fromUtf8("en s"));
    ui->qwtGraphiqueVitesse->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ui->qwtGraphiqueVitesse->setAxisTitle(ui->qwtGraphiqueVitesse->yLeft, QString::fromUtf8("en km/h"));
    ui->qwtGraphiqueVitesse->setAxisScale(QwtPlot::yLeft, 0.0, 100.0);

    ui->qwtGraphiqueTension->setAxisTitle(ui->qwtGraphiqueTension->xBottom, QString::fromUtf8("en s"));
    ui->qwtGraphiqueTension->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ui->qwtGraphiqueTension->setAxisTitle(ui->qwtGraphiqueTension->yLeft, QString::fromUtf8("en volt"));
    ui->qwtGraphiqueTension->setAxisScale(QwtPlot::yLeft, 34.0, 60.0);

    ui->qwtGraphiqueCourant->setAxisTitle(ui->qwtGraphiqueCourant->xBottom, QString::fromUtf8("en s"));
    ui->qwtGraphiqueCourant->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ui->qwtGraphiqueCourant->setAxisTitle(ui->qwtGraphiqueCourant->yLeft, QString::fromUtf8("en ampere"));
    ui->qwtGraphiqueCourant->setAxisScale(QwtPlot::yLeft, 0.0, 250.0);

    ui->qwtGraphiqueTemperature->setAxisTitle(ui->qwtGraphiqueTemperature->xBottom, QString::fromUtf8("en s"));
    ui->qwtGraphiqueTemperature->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ui->qwtGraphiqueTemperature->setAxisTitle(ui->qwtGraphiqueTemperature->yLeft, QString::fromUtf8("en °C"));
    ui->qwtGraphiqueTemperature->setAxisScale(QwtPlot::yLeft, 40.0, 100.0);

    ui->qwtGraphiqueChargeBatterie->setAxisTitle(ui->qwtGraphiqueChargeBatterie->xBottom, QString::fromUtf8("en s"));
    ui->qwtGraphiqueChargeBatterie->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ui->qwtGraphiqueChargeBatterie->setAxisTitle(ui->qwtGraphiqueChargeBatterie->yLeft, QString::fromUtf8("en %"));
    ui->qwtGraphiqueChargeBatterie->setAxisScale(QwtPlot::yLeft, 0.0, 100.0);



    //Instancier les courbes
    courbeVitesse = new QwtPlotCurve("Vitesse");
    courbeTension = new QwtPlotCurve("Tension");
    courbeCourant = new QwtPlotCurve("Courant");
    courbeTemperature = new QwtPlotCurve("Temperature");
    courbeChargeBatterie = new QwtPlotCurve("% Batterie");


    //ajout à la légende
    courbeVitesse->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    courbeTension->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    courbeCourant->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    courbeTemperature->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    courbeChargeBatterie->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);

    // tracé en bleu
    courbeVitesse->setPen(QPen(Qt::blue));
    courbeTension->setPen(QPen(Qt::blue));
    courbeCourant->setPen(QPen(Qt::blue));
    courbeTemperature->setPen(QPen(Qt::blue));
    courbeChargeBatterie->setPen(QPen(Qt::blue));



    // avec des points rouge
    courbeVitesse->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));
    courbeTension->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));
    courbeCourant->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));
    courbeTemperature->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));
    courbeChargeBatterie->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));


    // style de tracé
    courbeVitesse->setStyle(QwtPlotCurve::Lines); // ligne
    courbeVitesse->setCurveAttribute(QwtPlotCurve::Fitted);

    courbeTension->setStyle(QwtPlotCurve::Lines);
    courbeTension->setCurveAttribute(QwtPlotCurve::Fitted);

    courbeCourant->setStyle(QwtPlotCurve::Lines);
    courbeCourant->setCurveAttribute(QwtPlotCurve::Fitted);

    courbeTemperature->setStyle(QwtPlotCurve::Lines);
    courbeTemperature->setCurveAttribute(QwtPlotCurve::Fitted);

    courbeChargeBatterie->setStyle(QwtPlotCurve::Lines);
    courbeChargeBatterie->setCurveAttribute(QwtPlotCurve::Fitted);

    // la courbe
    courbeVitesse->setRenderHint(QwtPlotItem::RenderAntialiased);
    courbeTension->setRenderHint(QwtPlotItem::RenderAntialiased);
    courbeCourant->setRenderHint(QwtPlotItem::RenderAntialiased);
    courbeTemperature->setRenderHint(QwtPlotItem::RenderAntialiased);
    courbeChargeBatterie->setRenderHint(QwtPlotItem::RenderAntialiased);


    // la courbe sur le plot
    courbeVitesse->attach(ui->qwtGraphiqueVitesse);
    courbeTension->attach(ui->qwtGraphiqueTension);
    courbeCourant->attach(ui->qwtGraphiqueCourant);
    courbeTemperature->attach(ui->qwtGraphiqueTemperature);
    courbeChargeBatterie->attach(ui->qwtGraphiqueChargeBatterie);


}
IHMKart::rafraichir ( Echantillon  echantillon) [slot]
Paramètres:
echantillon

Références afficherDonneesTelemetrie(), afficherGraphiques(), Telemetrie::ajouterEchantillon(), et telemetrie.

Référencé par IHMKart().

{
    afficherDonneesTelemetrie(echantillon);
    telemetrie.ajouterEchantillon(echantillon);

    afficherGraphiques(echantillon);
}

Références chargeBatterie, courant, courbeChargeBatterie, courbeCourant, courbeTemperature, courbeTension, courbeVitesse, temperature, tension, ui, vitesse, Courbe::x, et Courbe::y.

Référencé par demarrerEssai().

{
    // on efface les tracés précédents
    vitesse.x.clear();
    vitesse.y.clear();
    courbeVitesse->setSamples(vitesse.x, vitesse.y);
    ui->qwtGraphiqueVitesse->replot();

    tension.x.clear();
    tension.y.clear();
    courbeTension->setSamples(tension.x, tension.y);
    ui->qwtGraphiqueTension->replot();

    courant.x.clear();
    courant.y.clear();
    courbeCourant->setSamples(courant.x, courant.y);
    ui->qwtGraphiqueCourant->replot();

    temperature.x.clear();
    temperature.y.clear();
    courbeTemperature->setSamples(temperature.x, temperature.y);
    ui->qwtGraphiqueTemperature->replot();


    chargeBatterie.x.clear();
    chargeBatterie.y.clear();
    courbeChargeBatterie->setSamples(chargeBatterie.x, chargeBatterie.y);
    ui->qwtGraphiqueChargeBatterie->replot();
}

Documentation des données membres

Association vers un objet Communication

Référencé par arreterEssai(), demarrerEssai(), et IHMKart().

QwtPlotCurve* IHMKart::courbeChargeBatterie [private]
QwtPlotCurve* IHMKart::courbeCourant [private]
QwtPlotCurve* IHMKart::courbeTemperature [private]
QwtPlotCurve* IHMKart::courbeTension [private]
QwtPlotCurve* IHMKart::courbeVitesse [private]

le graphique vitesse

Référencé par afficherGraphiques(), initialiserQWT(), et reinitialiserGraphiques().

QString IHMKart::idKart [private]

Référencé par arreterEssai(), et demarrerEssai().

QString IHMKart::idOperateur [private]

Composition d'un objet Telemetrie

Référencé par demarrerEssai(), et rafraichir().

Ui::IHMKart* IHMKart::ui [private]

les points de la courbe vitesse

Référencé par afficherGraphiques(), et reinitialiserGraphiques().


La documentation de cette classe a été générée à partir des fichiers suivants :
 Tout Classes Fichiers Fonctions Variables Macros