affiche les données télémétriques dans des widgets Plus de détails...

#include <ihmmaquette.h>

Graphe de collaboration de IHMmaquette:

Liste de tous les membres

Connecteurs publics

void rafraichir (Releve releve)
 rafraichir les données (vitesse, température,...)
void rafraichirGraphique (Releve releve)
 rafraichier les graphiques (Viteseen, Charge, courant, tension)
void demarrer ()
 le slot demarrer() du bouton
void Pause ()
 le slot Pause() du bouton
void Arreter ()
 le slot Arreter() du bouton
void selectionnerOperateur ()
 le slot selectionnerOperateur() de la ComboBox CodeOperateur
void selectionnerKart ()
 le slot selectionnerKart() de la ComboBox idKart
void exporter ()
 le slot exporter() du bouton exporter
void selectionnerDossierExport ()
 le slot selectionnerDossierExport() du boutonChemin
void selectionnerCourbe (int index)
 le slot selectionnerCourbe() de la ComboBox listCourbe

Fonctions membres publiques

 IHMmaquette (QWidget *parent=0)
 constructeur de la classe IHMmaquette
 ~IHMmaquette ()
 destructeur de la calasse IHMmaquette

Fonctions membres privées

void initialiserQwt ()
 initialise les widgets Qwt (Qwidget)
void initialiserOperateurs ()
 initialise les operateurs
void initialiserKarts ()
 initialise les karts
void initialiserIHM ()
 initialise l'ihm

Attributs privés

Ui::IHMMaquette * ihm
Acquisition acquisition
QTimer * timer
QPushButton * bouton
Karts karts
Kart kart
Operateurs operateurs
Operateur operateur
QwtPlotCurve * courbeVitesse
QwtPlotCurve * courbeCharge
QwtPlotCurve * courbeTension
QwtPlotCurve * courbeCourant
Courbe vitesse
Courbe charge
Courbe courant
Courbe tension
QVector< Relevereleves
QString idKart
QString codeOperateur
QString dossier
int index

Description détaillée

A faire:
Compléter les commentaires pour Doxygen
Auteur:
Tom Garcia
Version:
1.0

Documentation des constructeurs et destructeur

IHMmaquette::IHMmaquette ( QWidget *  parent = 0) [explicit]
Paramètres:
parent

Références acquisition, Arreter(), demarrer(), exporter(), ihm, initialiserIHM(), initialiserKarts(), initialiserOperateurs(), initialiserQwt(), Pause(), rafraichir(), rafraichirGraphique(), selectionnerCourbe(), selectionnerDossierExport(), selectionnerKart(), et selectionnerOperateur().

                                        : QMainWindow(parent),
    ihm(new Ui::IHMMaquette)
{
    ihm->setupUi(this);

    initialiserQwt();

    initialiserKarts();
    initialiserOperateurs();
    initialiserIHM();

    // nécessaire pour les paramétres d'un signal/slot
    qRegisterMetaType<Releve>("Releve");

    // onglet accueil
    connect(&acquisition, SIGNAL(nouveauReleve(Releve)), this, SLOT(rafraichir(Releve)));
    connect(ihm->BoutonDemarer, SIGNAL(clicked()),this,SLOT(demarrer()));
    connect(ihm->BoutonPause, SIGNAL(clicked()),this,SLOT(Pause()));
    connect(ihm->BoutonArreter, SIGNAL(clicked()),this,SLOT(Arreter()));
    connect(ihm->codeOperateur, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerOperateur()));
    connect(ihm->idKart, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerKart()));
    connect(ihm->BoutonQuitter, SIGNAL(clicked()),this,SLOT(close()));
    connect(ihm->BoutonQuitter2, SIGNAL(clicked()),this,SLOT(close()));

    // onglet graphique
    connect(&acquisition, SIGNAL(nouveauReleve(Releve)),this,SLOT(rafraichirGraphique(Releve)));
    connect(ihm->listeCourbes, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerCourbe(int)));
    connect(ihm->BoutonExporter, SIGNAL(clicked()),this,SLOT(exporter()));
    connect(ihm->BoutonChemin, SIGNAL(clicked()),this,SLOT(selectionnerDossierExport()));

    // showFullScreen();
    const int wi = qApp->desktop()->width();
    const int height = qApp->desktop()->height();
    resize(wi, height);
}

Documentation des fonctions membres

void IHMmaquette::Arreter ( ) [slot]

Références acquisition, Acquisition::arreter(), charge, courant, courbeCharge, courbeCourant, courbeTension, courbeVitesse, Acquisition::estDemarre(), ihm, tension, vitesse, Courbe::x, et Courbe::y.

Référencé par IHMmaquette().

{
    if(acquisition.estDemarre())
    {
        acquisition.arreter();        

        ihm->codeOperateur->setCurrentIndex(0);
        ihm->idKart->setCurrentIndex(0);
        ihm->BoutonDemarer->setEnabled(true);
        ihm->BoutonPause->setEnabled(false);
        ihm->BoutonArreter->setEnabled(false);
        ihm->Information->clear();

        // on efface les tracés
        vitesse.x.clear();
        vitesse.y.clear();
        courbeVitesse->setSamples(vitesse.x, vitesse.y);
        ihm->qwtGraphiqueVitesse->replot();
        charge.x.clear();
        charge.y.clear();
        courbeCharge->setSamples(charge.x, charge.y);
        ihm->qwtGraphiqueCharge->replot();
        tension.x.clear();
        tension.y.clear();
        courbeTension->setSamples(tension.x, tension.y);
        ihm->qwtGraphiqueTension->replot();
        courant.x.clear();
        courant.y.clear();
        courbeCourant->setSamples(courant.x, courant.y);
        ihm->qwtGraphiqueCourant->replot();

        //qDebug() << Q_FUNC_INFO << operateurs.getCodeOperateur(ihm->codeOperateur->currentIndex()) << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex());
        //qDebug() << Q_FUNC_INFO << karts.getIdKart(ihm->idKart->currentIndex()) << karts.getKartMarque(ihm->idKart->currentIndex());
    }
}
void IHMmaquette::demarrer ( ) [slot]

Références acquisition, codeOperateur, Acquisition::demarrer(), Acquisition::estArrete(), Acquisition::estDemarre(), Karts::getIdKart(), idKart, ihm, karts, et releves.

Référencé par IHMmaquette().

{
    if(acquisition.estArrete())
    {
        //qDebug() << Q_FUNC_INFO << operateurs.getCodeOperateur(ihm->codeOperateur->currentIndex()) << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex());
        //qDebug() << Q_FUNC_INFO << karts.getIdKart(ihm->idKart->currentIndex()) << karts.getKartMarque(ihm->idKart->currentIndex());

        acquisition.demarrer(karts.getIdKart(ihm->idKart->currentIndex()));
        if(acquisition.estDemarre())
        {
            idKart = ihm->idKart->currentText();
            codeOperateur = ihm->codeOperateur->currentText();
            releves.clear();
            ihm->BoutonDemarer->setEnabled(false);
            ihm->BoutonPause->setEnabled(true);
            ihm->BoutonArreter->setEnabled(true);
            ihm->labelFichier->setText(QString::fromUtf8("Fichier exporté : aucun"));
        }
    }
}
void IHMmaquette::exporter ( ) [slot]

Références Releve::chargeBatterie, codeOperateur, Releve::courant, Releve::date, dossier, Karts::getIdKart(), Karts::getKartMarque(), Operateurs::getOperateurNom(), Operateurs::getOperateurPrenom(), Releve::heure, idKart, ihm, karts, operateurs, releves, Releve::temperatureMoteur, Releve::tension, et Releve::vitesse.

Référencé par IHMmaquette().

{    
    // Le fichier CSV
    QDateTime maintenant = QDateTime::currentDateTime();
    // Format du nom de fichier : idOperateur_idKart_horodatage.csv
    QString nomFichier = dossier + "/" + idKart + "_" + codeOperateur + "_" + maintenant.toString("dd_MM_yyyy_hh_mm_ss") + ".csv";
    QFile *fichierCSV = new QFile(nomFichier);

    // Ouverture du fichier en mode texte et en écriture seule
    if (fichierCSV->open(QFile::WriteOnly | QIODevice::Text))
    {        
        // Ecriture des informations
        QTextStream info(fichierCSV);
        info << QString::fromUtf8(" Opérateur : ") << ";" << operateurs.getOperateurNom(ihm->codeOperateur->currentIndex()) << " " << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex()) << endl << " Kart : " << ";" << karts.getIdKart(ihm->idKart->currentIndex()) << ";" << karts.getKartMarque(ihm->idKart->currentIndex()) << endl << endl;

        // Ecriture de L'entete
        QTextStream entete(fichierCSV);
        entete << QString::fromUtf8("Date;Heure;Tension (Volts);Courant (A);Charge (%);Température (°C);Vitesse (km/h)") << endl;

    }
    else
    {
        QMessageBox::critical(0,"Erreur !",QString("Impossible d'ouvrir le fichier %1").arg(nomFichier));
        delete fichierCSV;
        return;
    }

    // Ecriture des données
    QTextStream datas(fichierCSV);
    for(int i = 1; i < releves.size(); i++)
    {
        Releve releve = releves.at(i);
        datas << releve.date  << ";" << releve.heure << ";" << releve.tension.replace(QString("."), QString(",")) << ";" << releve.courant.replace(QString("."), QString(",")) << ";" << releve.chargeBatterie.replace(QString("."), QString(",")) << ";" << releve.temperatureMoteur.replace(QString("."), QString(",")) << ";" << releve.vitesse.replace(QString("."), QString(",")) << endl;
    }

    ihm->BoutonExporter->setEnabled(false);
    releves.clear();

    ihm->Information->append("Exportation = " + fichierCSV->fileName());
    QFileInfo fi(fichierCSV->fileName());
    QString nom = fi.fileName();
    ihm->labelFichier->setText(QString::fromUtf8("Fichier exporté : ") + nom);
}

Références dossier, et ihm.

Référencé par IHMmaquette().

{
    dossier = qApp->applicationDirPath();
    ihm->labelDossier->setText("Dossier exportation : " + dossier);
    ihm->labelFichier->setText(QString::fromUtf8("Fichier exporté : aucun"));
    ihm->listeCourbes->addItem(QString::fromUtf8("Vitesse/Charge"));
    ihm->listeCourbes->addItem(QString::fromUtf8("Tension/Courant"));
    ihm->courbes->setCurrentIndex(ihm->listeCourbes->currentIndex());
    ihm->tabWidget->setCurrentIndex(0); // accueil
    ihm->BoutonDemarer->setEnabled(false);
    ihm->BoutonPause->setEnabled(false);
    ihm->BoutonArreter->setEnabled(false);
    ihm->BoutonExporter->setEnabled(true);//bref
}

Références Karts::getIdKart(), Karts::getNbKart(), ihm, et karts.

Référencé par IHMmaquette().

{
    ihm->idKart->addItem(QString(""));
    for(int i=0; i < karts.getNbKart(); i++)
    {
        ihm->idKart->addItem(karts.getIdKart(i+1));
    }
}

Références Operateurs::getCodeOperateur(), Operateurs::getNbOperateurs(), ihm, et operateurs.

Référencé par IHMmaquette().

{
    ihm->codeOperateur->addItem(QString(""));
    for(int i=0; i < operateurs.getNbOperateurs(); i++)
    {
        ihm->codeOperateur->addItem(operateurs.getCodeOperateur(i+1));
    }
}

< l'index pour parcourir les structures

< TODO

Références courbeCharge, courbeCourant, courbeTension, courbeVitesse, et ihm.

Référencé par IHMmaquette().

{
    // Vitesse
    // L'origine
    ihm->qwtVitesse->setOrigin(135.0);
    ihm->qwtVitesse->setScaleArc(0.0, 270.0);
    ihm->qwtVitesse->setScale(0, 10, 10);
    ihm->qwtVitesse->scaleDraw()->setSpacing(4);
    ihm->qwtVitesse->setRange(0,140,10);
    ihm->qwtVitesse->setReadOnly(true);

    // Aiguille
    QwtDialSimpleNeedle *needle = new QwtDialSimpleNeedle( QwtDialSimpleNeedle::Arrow, true, Qt::red, QColor(Qt::black).light(70)); 
    ihm->qwtVitesse->setNeedle(needle);
    ihm->qwtVitesse->setScaleComponents( QwtAbstractScaleDraw::Ticks | QwtAbstractScaleDraw::Labels );
    ihm->qwtVitesse->setScaleTicks(0, 0, 4);

    // modifier les couleurs QwtVitesse
    QPalette p2 = ihm->qwtVitesse->palette();
    p2.setColor(QPalette::Base, QColor(80, 100, 255));
    p2.setColor(QPalette::WindowText, QColor(128, 128, 128));
    p2.setColor(QPalette::Text, QColor(255, 255, 255));
    ihm->qwtVitesse->setPalette(p2);

    // Batterie (charge)
    ihm->QwtBatterie->setScale(0,100,10);
    ihm->QwtBatterie->setMinValue(0);
    ihm->QwtBatterie->setMaxValue(100);
    ihm->QwtBatterie->setValue(0.0);

    // modifier les couleurs QwtBatteries
    QPalette p3 = ihm->QwtBatterie->palette();
    p3.setColor(QPalette::Base, QColor(128, 128, 128));  //base
    p3.setColor(QPalette::WindowText, QColor(80, 100, 255));
    p3.setColor(QPalette::ButtonText, QColor(80, 100, 255));
    p3.setColor(QPalette::Text, QColor(0, 0, 0));
    ihm->QwtBatterie->setPalette(p3);

    // QwtA (ampère)
    ihm->QwtA->setScale(0, 350, 50);
    ihm->QwtA->setMinValue(0);
    ihm->QwtA->setMaxValue(350);
    ihm->QwtA->setValue(0.0);

    // modifier les couleurs QwtA
    QPalette p4 = ihm->QwtA->palette();
    p4.setColor(QPalette::Base, QColor(128, 128, 128));
    p4.setColor(QPalette::WindowText, QColor(80, 100, 255));
    p4.setColor(QPalette::ButtonText, QColor(80, 100, 255));
    p4.setColor(QPalette::Text, QColor(0, 0, 0));
    ihm->QwtA->setPalette(p4);

    // QwtV (volt)
    ihm->QwtV->setScale(0, 50, 5);
    ihm->QwtV->setMinValue(0);
    ihm->QwtV->setMaxValue(50);
    ihm->QwtV->setValue(0.0);

    // modifier les couleurs QwtV
    QPalette p5 = ihm->QwtV->palette();
    p5.setColor(QPalette::Base, QColor(128, 128, 128));
    p5.setColor(QPalette::WindowText, QColor(80, 100, 255));
    p5.setColor(QPalette::ButtonText, QColor(80, 100, 255));
    p5.setColor(QPalette::Text, QColor(0, 0, 0));
    ihm->QwtV->setPalette(p5);

    // QwtTermoKart (degré du moteur)
    ihm->QwtThermoKart->setScale(0, 80, 10);
    ihm->QwtThermoKart->setMinValue(0);
    ihm->QwtThermoKart->setMaxValue(80);
    ihm->QwtThermoKart->setValue(0.0);

    // modifier les couleurs QwtThermoKart
    QPalette p6 = ihm->QwtThermoKart->palette();
    p6.setColor(QPalette::Base, QColor(128, 128, 128));
    p6.setColor(QPalette::WindowText, QColor(80, 100, 255));
    p6.setColor(QPalette::ButtonText, QColor(80, 100, 255));
    p6.setColor(QPalette::Text, QColor(0, 0, 0));
    ihm->QwtThermoKart->setPalette(p6);

    QwtPlotGrid *grid;
    // Les QwtPlot
    // Un titre
    ihm->qwtGraphiqueCharge->setTitle(QString::fromUtf8("Charge"));
    // une légende à droite
    ihm->qwtGraphiqueCharge->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    // cadrillage
    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ihm->qwtGraphiqueCharge);
    // configuration des axes
    ihm->qwtGraphiqueCharge->setAxisTitle(ihm->qwtGraphiqueCharge->xBottom, QString::fromUtf8("en s -->"));
    ihm->qwtGraphiqueCharge->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ihm->qwtGraphiqueCharge->setAxisTitle(ihm->qwtGraphiqueCharge->yLeft, QString::fromUtf8("en % -->"));
    ihm->qwtGraphiqueCharge->setAxisScale(QwtPlot::yLeft, 0.0, 100.0);

    // Un titre
    ihm->qwtGraphiqueVitesse->setTitle(QString::fromUtf8("Vitesse"));
    // une légende à droite
    ihm->qwtGraphiqueVitesse->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    // cadrillage
    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ihm->qwtGraphiqueVitesse);
    // configuration des axes
    ihm->qwtGraphiqueVitesse->setAxisTitle(ihm->qwtGraphiqueVitesse->xBottom, QString::fromUtf8("en s -->"));
    ihm->qwtGraphiqueVitesse->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ihm->qwtGraphiqueVitesse->setAxisTitle(ihm->qwtGraphiqueVitesse->yLeft, QString::fromUtf8("en km/h -->"));
    ihm->qwtGraphiqueVitesse->setAxisScale(QwtPlot::yLeft, 0.0, 100.0);

    // Un titre
    ihm->qwtGraphiqueTension->setTitle(QString::fromUtf8("Tension"));
    // une légende à droite
    ihm->qwtGraphiqueTension->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    // cadrillage
    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ihm->qwtGraphiqueTension);
    // configuration des axes
    ihm->qwtGraphiqueTension->setAxisTitle(ihm->qwtGraphiqueTension->xBottom, QString::fromUtf8("en s -->"));
    ihm->qwtGraphiqueTension->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ihm->qwtGraphiqueTension->setAxisTitle(ihm->qwtGraphiqueTension->yLeft, QString::fromUtf8("en V -->"));
    ihm->qwtGraphiqueTension->setAxisScale(QwtPlot::yLeft, 0.0, 50.0);

    // Un titre
    ihm->qwtGraphiqueCourant->setTitle(QString::fromUtf8("Courant"));
    // une légende à droite
    ihm->qwtGraphiqueCourant->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    // cadrillage
    grid = new QwtPlotGrid;
    grid->setMajPen(QPen(Qt::black, 0, Qt::DotLine));
    grid->attach(ihm->qwtGraphiqueCourant);
    // configuration des axes
    ihm->qwtGraphiqueCourant->setAxisTitle(ihm->qwtGraphiqueCourant->xBottom, QString::fromUtf8("en s -->"));
    ihm->qwtGraphiqueCourant->setAxisScale(QwtPlot::xBottom, 0.0, 59.0);
    ihm->qwtGraphiqueCourant->setAxisTitle(ihm->qwtGraphiqueCourant->yLeft, QString::fromUtf8("en A -->"));
    ihm->qwtGraphiqueCourant->setAxisScale(QwtPlot::yLeft, 0.0, 350.0);

    //Instancier les courbes
    courbeVitesse = new QwtPlotCurve("Vitesse");
    //ajout à la légende
    courbeVitesse->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    // tracé en bleu
    courbeVitesse->setPen(QPen(Qt::blue));
    // avec des points rouge
    courbeVitesse->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);
    // la courbe
    courbeVitesse->setRenderHint(QwtPlotItem::RenderAntialiased);
    // la courbe sur le plot
    courbeVitesse->attach(ihm->qwtGraphiqueVitesse);

    courbeCharge = new QwtPlotCurve("Charge");
    //ajout à la légende
    courbeCharge->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    // tracé en bleu
    courbeCharge->setPen(QPen(Qt::red));
    // avec des points rouge
    courbeCharge->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::blue, QPen(Qt::black), QSize(5,5)));
    // style de tracé
    courbeCharge->setStyle(QwtPlotCurve::Lines); // ligne
    courbeCharge->setCurveAttribute(QwtPlotCurve::Fitted);
    // la courbe
    courbeCharge->setRenderHint(QwtPlotItem::RenderAntialiased);
    // la courbe sur le plot
    courbeCharge->attach(ihm->qwtGraphiqueCharge);

    courbeTension = new QwtPlotCurve("Tension");
    //ajout à la légende
    courbeTension->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    // tracé en bleu
    courbeTension->setPen(QPen(Qt::red));
    // avec des points rouge
    courbeTension->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::blue, QPen(Qt::black), QSize(5,5)));
    // style de tracé
    courbeTension->setStyle(QwtPlotCurve::Lines); // ligne
    courbeTension->setCurveAttribute(QwtPlotCurve::Fitted);
    // la courbe
    courbeTension->setRenderHint(QwtPlotItem::RenderAntialiased);
    // la courbe sur le plot
    courbeTension->attach(ihm->qwtGraphiqueTension);

    courbeCourant = new QwtPlotCurve("Courant");
    //ajout à la légende
    courbeCourant->setLegendAttribute(QwtPlotCurve::LegendShowLine, true);
    // tracé en bleu
    courbeCourant->setPen(QPen(Qt::blue));
    // avec des points rouge
    courbeCourant->setSymbol(new QwtSymbol(QwtSymbol::Ellipse, Qt::red, QPen(Qt::black), QSize(5,5)));
    // style de tracé
    courbeCourant->setStyle(QwtPlotCurve::Lines); // ligne
    courbeCourant->setCurveAttribute(QwtPlotCurve::Fitted);
    // la courbe
    courbeCourant->setRenderHint(QwtPlotItem::RenderAntialiased);
    // la courbe sur le plot
    courbeCourant->attach(ihm->qwtGraphiqueCourant);

    // Gestion des boutons
    ihm->BoutonDemarer->setDisabled(false);
    ihm->BoutonPause->setDisabled(true);
    ihm->BoutonArreter->setDisabled(true);
}
void IHMmaquette::Pause ( ) [slot]

Références acquisition, Acquisition::arreter(), Acquisition::demarrer(), Acquisition::estArrete(), Acquisition::estDemarre(), Karts::getIdKart(), ihm, et karts.

Référencé par IHMmaquette().

{
    if(ihm->BoutonPause->text() == "Pause")
    {
        if(acquisition.estDemarre())
        {
            acquisition.arreter();

            //qDebug() << Q_FUNC_INFO << operateurs.getCodeOperateur(ihm->codeOperateur->currentIndex()) << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex());
            //qDebug() << Q_FUNC_INFO << karts.getIdKart(ihm->idKart->currentIndex()) << karts.getKartMarque(ihm->idKart->currentIndex());

            ihm->BoutonPause->setText("Reprendre");
            ihm->BoutonPause->setDisabled(false);
            ihm->BoutonArreter->setDisabled(true);
        }
    }
    else
    {
        if(acquisition.estArrete())
        {
            ihm->BoutonPause->setText("Pause");
            ihm->BoutonPause->setDisabled(false);
            ihm->BoutonArreter->setDisabled(false);

            //qDebug() << Q_FUNC_INFO << operateurs.getCodeOperateur(ihm->codeOperateur->currentIndex()) << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex());
            //qDebug() << Q_FUNC_INFO << karts.getIdKart(ihm->idKart->currentIndex()) << karts.getKartMarque(ihm->idKart->currentIndex());

            acquisition.demarrer(karts.getIdKart(ihm->idKart->currentIndex()));
        }
    }
}
IHMmaquette::rafraichir ( Releve  releve) [slot]
Paramètres:
releve

Références Releve::chargeBatterie, Releve::courant, ihm, releves, Releve::temperatureMoteur, Releve::tension, et Releve::vitesse.

Référencé par IHMmaquette().

{
    ihm->QwtThermoKart->setValue(releve.temperatureMoteur.toFloat());
    ihm->QwtBatterie->setValue(releve.chargeBatterie.toFloat());
    ihm->QwtA->setValue(releve.courant.toFloat());
    ihm->QwtV->setValue(releve.tension.toFloat());
    ihm->qwtVitesse->setValue(releve.vitesse.toFloat());

    // on stocke le relevé pour l'exporter plus tard
    releves.push_back(releve);

    ihm->BoutonExporter->setEnabled(true);
}
Paramètres:
releve

Références charge, Releve::chargeBatterie, Releve::courant, courant, courbeCharge, courbeCourant, courbeTension, courbeVitesse, ihm, Releve::tension, tension, Releve::vitesse, vitesse, Courbe::x, et Courbe::y.

Référencé par IHMmaquette().

{
    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);
        ihm->qwtGraphiqueVitesse->replot();

        charge.x.clear();
        charge.y.clear();
        courbeCharge->setSamples(charge.x, charge.y);
        ihm->qwtGraphiqueCharge->replot();

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

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

    // on ajoute les mesures
    vitesse.x.push_back((double)seconde);
    vitesse.y.push_back(releve.vitesse.toDouble());
    charge.x.push_back((double)seconde);
    charge.y.push_back(releve.chargeBatterie.toDouble());
    tension.x.push_back((double)seconde);
    tension.y.push_back(releve.tension.toDouble());
    courant.x.push_back((double)seconde);
    courant.y.push_back(releve.courant.toDouble());

    // on trace les points x,y
    courbeVitesse->setSamples(vitesse.x, vitesse.y);
    ihm->qwtGraphiqueVitesse->replot();
    courbeCharge->setSamples(charge.x, charge.y);
    ihm->qwtGraphiqueCharge->replot();
    courbeTension->setSamples(tension.x, tension.y);
    ihm->qwtGraphiqueTension->replot();
    courbeCourant->setSamples(courant.x, courant.y);
    ihm->qwtGraphiqueCourant->replot();
}
void IHMmaquette::selectionnerCourbe ( int  index) [slot]

Références ihm.

Référencé par IHMmaquette().

{
    ihm->courbes->setCurrentIndex(ihm->listeCourbes->currentIndex());
}

Références dossier, et ihm.

Référencé par IHMmaquette().

{
    QString dir = QFileDialog::getExistingDirectory(this, "Projet Kart", qApp->applicationDirPath(), QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);

    if(!dir.isEmpty())
    {
        dossier = dir;
        ihm->labelDossier->setText("Dossier exportation : " + dossier);
    }
}

Références Karts::getIdKart(), Karts::getKartMarque(), ihm, et karts.

Référencé par IHMmaquette().

{
    if(ihm->idKart->currentIndex()>0)
    {
        ihm->Information->append("Kart : ");
        ihm->Information->append("id kart = " + karts.getIdKart(ihm->idKart->currentIndex()));
        ihm->Information->append("marque = " + karts.getKartMarque(ihm->idKart->currentIndex()));
    }
    //qDebug() << Q_FUNC_INFO << karts.getKartMarque(ihm->idKart->currentIndex());
    if((ihm->idKart->currentIndex() > 0) && ((ihm->codeOperateur->currentIndex()) > 0))
    {

        ihm->BoutonDemarer->setEnabled(true);
    }
    else
    {
        ihm->BoutonDemarer->setEnabled(false);
    }
}

Références Operateurs::getCodeOperateur(), Operateurs::getOperateurNom(), Operateurs::getOperateurPrenom(), ihm, et operateurs.

Référencé par IHMmaquette().

{
    if(ihm->codeOperateur->currentIndex()>0)
    {
        ihm->Information->append("Operateur : ");
        ihm->Information->append("code operateur = " + operateurs.getCodeOperateur(ihm->codeOperateur->currentIndex()));
        ihm->Information->append("prenom = " + operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex()));
        ihm->Information->append("nom = " + operateurs.getOperateurNom(ihm->codeOperateur->currentIndex()));
    }
    //qDebug() << Q_FUNC_INFO << operateurs.getOperateurPrenom(ihm->codeOperateur->currentIndex());
    //qDebug() << Q_FUNC_INFO << operateurs.getOperateurNom(ihm->codeOperateur->currentIndex());
    if((ihm->codeOperateur->currentIndex() > 0) && ((ihm->idKart->currentIndex()) > 0))
    {
        ihm->BoutonDemarer->setEnabled(true);
    }
    else
    {
        ihm->BoutonDemarer->setEnabled(false);
    }
}

Documentation des données membres

un objet acquisition

Référencé par Arreter(), demarrer(), IHMmaquette(), Pause(), et ~IHMmaquette().

QPushButton* IHMmaquette::bouton [private]

un boutton de l'ihm

les points de la courbe charge

Référencé par Arreter(), et rafraichirGraphique().

QString IHMmaquette::codeOperateur [private]

< correspond à l'identifiant d'un kart

Référencé par demarrer(), et exporter().

les points de la courbe courant

Référencé par Arreter(), et rafraichirGraphique().

QwtPlotCurve* IHMmaquette::courbeCharge [private]

le graphique charge

Référencé par Arreter(), initialiserQwt(), et rafraichirGraphique().

QwtPlotCurve* IHMmaquette::courbeCourant [private]

le graphique tension

Référencé par Arreter(), initialiserQwt(), et rafraichirGraphique().

QwtPlotCurve* IHMmaquette::courbeTension [private]

le graphique courant

Référencé par Arreter(), initialiserQwt(), et rafraichirGraphique().

QwtPlotCurve* IHMmaquette::courbeVitesse [private]

le graphique vitesse

Référencé par Arreter(), initialiserQwt(), et rafraichirGraphique().

QString IHMmaquette::dossier [private]

< correspond au code d'un opérateur

Référencé par exporter(), initialiserIHM(), et selectionnerDossierExport().

QString IHMmaquette::idKart [private]

Référencé par demarrer(), et exporter().

int IHMmaquette::index [private]

< permet de choisir le dossier de l'exportation

un objet kart

un objet karts qui correspond au information du fichier kart.xml

Référencé par demarrer(), exporter(), initialiserKarts(), Pause(), et selectionnerKart().

un objet operateur

un objet operateurs qui correspond au information du fichier operateur.xml

Référencé par exporter(), initialiserOperateurs(), et selectionnerOperateur().

QVector<Releve> IHMmaquette::releves [private]

les relevés de mesures pour l'exportation

Référencé par demarrer(), exporter(), et rafraichir().

les points de la courbe tension

Référencé par Arreter(), et rafraichirGraphique().

QTimer* IHMmaquette::timer [private]

correspond au timer

les points de la courbe vitesse

Référencé par Arreter(), et rafraichirGraphique().


La documentation de cette classe a été générée à partir des fichiers suivants :