BeeHoneyt  1.1
BTS SNIR LaSalle Avignon 2021
ihmpc.cpp
Aller à la documentation de ce fichier.
1 #include "ihmpc.h"
2 #include "ui_ihmpc.h"
3 #include "ruche.h"
4 #include "communication.h"
5 #include "historique.h"
6 #include "alertes.h"
7 #include <QDebug>
8 #include <QGraphicsScene>
9 #include <QGraphicsRectItem>
10 #include <QGraphicsView>
11 #include <QObject>
12 
29 IHMPc::IHMPc(QWidget *parent) : QMainWindow(parent),
30  ui(new Ui::IHMPc),
31  communicationTTN(new Communication(this)),
32  historique(new Historique(this)),
33  indexRucheSelectionnee(-1)
34 {
35  qDebug() << Q_FUNC_INFO;
36 
38 
39  creerRucher();
40 
42 
44 
46 
47  QString url = "https://" + communicationTTN->getUsername() + ".data.thethingsnetwork.org";
49 }
50 
56 {
57  if(indexRucheSelectionnee > -1)
59  delete ui;
60  qDebug() << Q_FUNC_INFO;
61 }
62 
70 void IHMPc::afficherTemperatureInterieure(double temperatureInterieure, QString uniteTemperature) const
71 {
72  ui->lcdTemperatureInterieure->display(temperatureInterieure);
73  ui->labelUniteTemperatureInterieure->setText(uniteTemperature);
74 }
75 
83 void IHMPc::afficherTemperatureExterieure(double temperatureExterieure, QString uniteTemperature) const
84 {
85  ui->lcdTemperatureExterieure->display(temperatureExterieure);
86  ui->labelUniteTemperatureExterieure->setText(uniteTemperature);
87 }
88 
96 void IHMPc::afficherHumiditeInterieure(double humiditeInterieure, QString uniteHumidite) const
97 {
98  ui->lcdHumiditeInterieure->display(humiditeInterieure);
99  ui->labelUniteHumiditeInterieure->setText(uniteHumidite);
100 }
101 
109 void IHMPc::afficherHumiditeExterieure(double humiditeExterieure, QString uniteHumidite) const
110 {
111  ui->lcdHumiditeExterieure->display(humiditeExterieure);
112  ui->labelUniteHumiditeExterieure->setText(uniteHumidite);
113 }
114 
122 void IHMPc::afficherPoids(double poids, QString unitePoids) const
123 {
124  ui->lcdPoids->display(poids);
125  ui->labelUnitePoids->setText(unitePoids);
126 }
127 
135 void IHMPc::afficherPression(double pression, QString unitePression) const
136 {
137  ui->lcdPression->display(pression);
138  ui->labelUnitePression->setText(unitePression);
139 }
140 
147 {
148  ui->boutonTTN->setText("Déconnecter");
149  ui->labelEtatConnexion->setPixmap(QPixmap(QDir::currentPath() + "/images/boutton_vert.png"));
150  qDebug() << Q_FUNC_INFO << "Ruche sélectionnée (connectee)" << ui->listeRuches->currentText() << rucher[ui->listeRuches->currentIndex()]->getDeviceID();
151  indexRucheSelectionnee = ui->listeRuches->currentIndex();
152  communicationTTN->abonner(rucher[ui->listeRuches->currentIndex()]->getDeviceID());
153 }
154 
161 {
162  ui->boutonTTN->setText("Connecter");
163  ui->labelHorodatage->setText("");
164  ui->lcdTemperatureInterieure->display(0.);
165  ui->lcdTemperatureExterieure->display(0.);
166  ui->lcdHumiditeInterieure->display(0.);
167  ui->lcdHumiditeExterieure->display(0.);
168  ui->lcdPoids->display(0.);
169  ui->lcdPression->display(0.);
170  ui->labelAlerteTemperatureExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
171  ui->labelAlerteTemperatureInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
172  ui->labelAlerteHumiditeExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
173  ui->labelAlerteHumiditeInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
174  ui->labelAlertePoids->setPixmap(QPixmap(QDir::currentPath() + ""));
175  ui->labelAlertePression->setPixmap(QPixmap(QDir::currentPath() + ""));
176 
177  ui->labelEtatConnexion->setPixmap(QPixmap(QDir::currentPath() + "/images/boutton_rouge.png"));
178  qDebug() << Q_FUNC_INFO << "Ruche sélectionnée (deconnectee)" << ui->listeRuches->currentText() << rucher[ui->listeRuches->currentIndex()]->getDeviceID();
179 }
186 {
191  afficherAlertePoids(mesure.getPoids());
193 }
200 {
201  if(alertes.verifierTemperatureExterieure(temperature))
202  {
203  ui->labelAlerteTemperatureExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
204  }
205  else
206  {
207  ui->labelAlerteTemperatureExterieure->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
208  }
209 }
216 {
217  if(alertes.verifierTemperatureInterieure(temperature))
218  {
219  ui->labelAlerteTemperatureInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
220  }
221  else
222  {
223  ui->labelAlerteTemperatureInterieure->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
224  }
225 }
232 {
233  if(alertes.verifierHumiditeExterieure(humidite))
234  {
235  ui->labelAlerteHumiditeExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
236  }
237  else
238  {
239  ui->labelAlerteHumiditeExterieure->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
240  }
241 }
248 {
249  if(alertes.verifierHumiditeInterieure(humidite))
250  {
251  ui->labelAlerteHumiditeInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
252  }
253  else
254  {
255  ui->labelAlerteHumiditeInterieure->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
256  }
257 }
263 void IHMPc::afficherAlertePoids(double poids)
264 {
265  if(alertes.verifierPoids(poids))
266  {
267  ui->labelAlertePoids->setPixmap(QPixmap(QDir::currentPath() + ""));
268  }
269  else
270  {
271  ui->labelAlertePoids->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
272  }
273 }
279 void IHMPc::afficherAlertePression(double pression)
280 {
281  if(alertes.verifierPression(pression))
282  {
283  ui->labelAlertePression->setPixmap(QPixmap(QDir::currentPath() + ""));
284  }
285  else
286  {
287  ui->labelAlertePression->setPixmap(QPixmap(QDir::currentPath() + "/images/attention-rouge.png"));
288  }
289 }
290 
297 {
298  ui->setupUi(this);
299  ui->ongletIHM->setCurrentIndex(OngletIHM::ONGLET_MESURES);
300 
301  creerGraphique();
302 
303  showMaximized();
304 }
305 
312 {
313  // Tests d'un rucher composé de deux ruches (simulateur)
314  rucher.push_back(new Ruche("Ruche BeeHoneyT", "bee-honeyt-1", this));
315  rucher.push_back(new Ruche("Ruche 1", "ruche-1-sim", this));
316  //rucher.push_back(new Ruche("Ruche 2", "ruche-2-sim", this));
317 
318  for(int i=0;i<rucher.size();++i)
319  {
320  ui->listeRuches->addItem(rucher[i]->getNom());
321  }
322 
324  ui->listeRuches->setCurrentIndex(indexRucheSelectionnee);
325  ui->labelRucheSelectionnee->setText("Ruche sélectionnée : " + ui->listeRuches->currentText());
326 }
327 
334 {
335  qRegisterMetaType<MesureRuche>();
336  connect(communicationTTN, SIGNAL(ttnConnecte()), this, SLOT(afficherEtatConnecte()));
337  connect(communicationTTN, SIGNAL(ttnDeconnecte()), this, SLOT(afficherEtatDeconnecte()));
338  connect(communicationTTN, SIGNAL(messageJournal(QString)), this, SLOT(journaliser(QString)));
339  qRegisterMetaType<MesureRuche>();
340  connect(communicationTTN, SIGNAL(nouvellesMesures(MesureRuche)), this, SLOT(afficherNouvellesMesures(MesureRuche)));
341  connect(historique, SIGNAL(messageJournal(QString)), this, SLOT(journaliser(QString)));
342 
343  connect(ui->boutonTTN, SIGNAL(clicked(bool)), this, SLOT(gererConnexionTTN()));
344  connect(ui->boutonAjouter, SIGNAL(clicked(bool)), this, SLOT(ouvrirFenetreAjouter()));
345  connect(ui->boutonSupprimer, SIGNAL(clicked(bool)), this, SLOT(supprimerRuche()));
346  connect(ui->boutonAlertes, SIGNAL(clicked(bool)), this, SLOT(configurerAlertes()));
347  connect(ui->boutonConfigurerTTN, SIGNAL(clicked(bool)), this, SLOT(configurerConnexionTTN()));
348  connect(ui->listeRuches, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerRuche()));
349  connect(ui->ongletIHM, SIGNAL(currentChanged(int)), this, SLOT(gererChangementOnglet(int)));
350 
351  connect(ui->listeMesuresGraphiques, SIGNAL(currentIndexChanged(int)), this, SLOT(selectionnerGraphique()));
352  connect(ui->bouttonRecharger, SIGNAL(clicked(bool)), this, SLOT(rechargerGraphique()));
353  connect(historique, SIGNAL(recuperationTerminee()), this, SLOT(selectionnerGraphique()));
354 }
360 {
373 }
380 {
381  QString nomNouvelleRuche = QInputDialog::getText(this, "Ajouter", "Veuillez entrer le nom de la Ruche : ", QLineEdit::Normal, QString());
382  if (!nomNouvelleRuche.isEmpty())
383  {
384  QString deviceIDNouvelleRuche = QInputDialog::getText(this, "Ajouter", "Veuillez entrer le deviceID de la Ruche : ", QLineEdit::Normal, QString());
385  if(!deviceIDNouvelleRuche.isEmpty())
386  {
387  rucher.push_back(new Ruche(nomNouvelleRuche, deviceIDNouvelleRuche, this));
388  ui->listeRuches->addItem(rucher[rucher.size() - 1]->getNom());
389  qDebug() << Q_FUNC_INFO << "Ruche ajoutée" << rucher[rucher.size() - 1]->getNom();
390  ui->listeRuches->setCurrentIndex(rucher.size() - 1);
391  }
392  else
393  {
394  QMessageBox::critical(this, "Device ID", "Champ de saisi vide !");
395  }
396  }
397  else
398  {
399  QMessageBox::critical(this, "Nom de la ruche", "Champ de saisi vide !");
400  }
404 }
405 
412 {
413  for(int i=0;i<rucher.size();++i)
414  {
415  if(rucher[i]->getNom() == ui->listeRuches->currentText())
416  {
417  qDebug() << Q_FUNC_INFO << "Ruche supprimée" << rucher[i]->getNom();
418  communicationTTN->desabonner(rucher[ui->listeRuches->currentIndex()]->getDeviceID());
420  delete rucher.at(i);
421  rucher.remove(i);
422  ui->labelRucheSelectionnee->setText("Ruche sélectionnée : aucune");
423  ui->listeRuches->removeItem(ui->listeRuches->currentIndex());
424  return;
425  }
426  }
427 }
428 
434 {
435 
436  double temperatureExterieureMax = QInputDialog::getDouble(this, "Configurer les alertes", "Temperature exterieure maximale : ", QLineEdit::Normal, double());
437  alertes.setTemperatureExterieureMax(temperatureExterieureMax);
438  QString messageTemperature = "Seuils d'alertes changes : temperatures ext. max. = ";
439  messageTemperature.append(QString::number(temperatureExterieureMax));
440 
441  double temperatureExterieureMin = QInputDialog::getDouble(this, "Configurer les alertes", "Temperature exterieure minimale : ", QLineEdit::Normal, double());
442  alertes.setTemperatureExterieureMin(temperatureExterieureMin);
443  messageTemperature += ", temperatures ext. min. = ";
444  messageTemperature.append(QString::number(temperatureExterieureMin));
445 
446  double temperatureInterieureMax = QInputDialog::getDouble(this, "Configurer les alertes", "Temperature interieure maximale : ", QLineEdit::Normal, double());
447  alertes.setTemperatureInterieureMax(temperatureInterieureMax);
448  messageTemperature += ", temperatures int. max. = ";
449  messageTemperature.append(QString::number(temperatureInterieureMax));
450 
451  double temperatureInterieureMin = QInputDialog::getDouble(this, "Configurer les alertes", "Temperature interieure minimale : ", QLineEdit::Normal, double());
452  alertes.setTemperatureInterieureMin(temperatureInterieureMin);
453  messageTemperature += ", temperatures int. min. = ";
454  messageTemperature.append(QString::number(temperatureInterieureMin));
455 
456  journaliser(messageTemperature);
457 
458  double humiditeExterieureMax = QInputDialog::getDouble(this, "Configurer les alertes", "Humidite exterieure maximale : ", QLineEdit::Normal, double());
459  alertes.setHumiditeExterieureMax(humiditeExterieureMax);
460  QString messageHumidite = "Seuils d'alertes changes : humidite ext. max. = ";
461  messageHumidite.append(QString::number(humiditeExterieureMax));
462 
463  double humiditeExterieureMin = QInputDialog::getDouble(this, "Configurer les alertes", "Humidite exterieure minimale : ", QLineEdit::Normal, double());
464  alertes.setHumiditeExterieureMin(humiditeExterieureMin);
465  messageHumidite += ", humidite ext. min. = ";
466  messageHumidite.append(QString::number(humiditeExterieureMin));
467 
468  double humiditeInterieureMax = QInputDialog::getDouble(this, "Configurer les alertes", "Humidite interieure maximale : ", QLineEdit::Normal, double());
469  alertes.setHumiditeInterieureMax(humiditeInterieureMax);
470  messageHumidite += ", humidite int. max. = ";
471  messageHumidite.append(QString::number(humiditeInterieureMax));
472 
473  double humiditeInterieureMin = QInputDialog::getDouble(this, "Configurer les alertes", "Humidite interieure minimale : ", QLineEdit::Normal, double());
474  alertes.setHumiditeInterieureMin(humiditeInterieureMin);
475  messageHumidite += ", humidite int. min. = ";
476  messageHumidite.append(QString::number(humiditeInterieureMin));
477 
478  journaliser(messageHumidite);
479 
480  double pressionMax = QInputDialog::getDouble(this, "Configurer les alertes", "Pression maximale : ", QLineEdit::Normal, double());
481  alertes.setPressionMax(pressionMax);
482  QString messagePression = "Seuils d'alertes changes : pression max. = ";
483  messagePression.append(QString::number(pressionMax));
484 
485  double pressionMin = QInputDialog::getDouble(this, "Configurer les alertes", "Pression minimale : ", QLineEdit::Normal, double());
486  alertes.setPressionMin(pressionMin);
487  messagePression += ", pression min. = ";
488  messagePression.append(QString::number(pressionMin));
489 
490  journaliser(messagePression);
491 
492  double poidsMax = QInputDialog::getDouble(this, "Configurer les alertes", "Poids maximale : ", QLineEdit::Normal, double());
493  alertes.setPoidsMax(poidsMax);
494  QString messagePoids = "Seuils d'alertes changes : poids max. = ";
495  messagePoids.append(QString::number(poidsMax));
496 
497  double poidsMin = QInputDialog::getDouble(this, "Configurer les alertes", "Poids minimale : ", QLineEdit::Normal, double());
498  alertes.setPoidsMin(poidsMin);
499  messagePoids += ", poids min. = ";
500  messagePoids.append(QString::number(poidsMin));
501 
502  journaliser(messagePoids);
503 
504 
505 }
511 {
512  QString applicationID = QInputDialog::getText(this, "Configuration TTN", "Veuillez entrer l'application ID : ", QLineEdit::Normal, QString());
513  if (!applicationID.isEmpty())
514  {
515  QString motDePasse = QInputDialog::getText(this, "Configuration TTN", "Veuillez entrer la clé : ", QLineEdit::Normal, QString());
516  if(!motDePasse.isEmpty())
517  {
518  communicationTTN->reconnecter(communicationTTN->getHostname(),1883, applicationID, motDePasse);
519  }
520  else
521  {
522  QMessageBox::critical(this, "Configuration TTN", "Champ de mot de passe vide !");
523  }
524  }
525  else
526  {
527  QMessageBox::critical(this, "Configuration TTN", "Champ de l'Application ID vide !");
528  }
529 }
536 void IHMPc::afficherHorodatage(QString horodatage)
537 {
538  ui->labelHorodatage->setText(horodatage);
539 }
547 {
548  if(!mesure.getHorodatage().isEmpty())
549  {
551  afficherPoids(mesure.getPoids());
556  afficherPression(mesure.getPression());
557  verifierAlertes(mesure);
558  }
559 }
566 {
567  if(indexRucheSelectionnee > -1)
569  if(ui->listeRuches->count() > 0)
570  {
571  qDebug() << Q_FUNC_INFO << "Ruche sélectionnée" << ui->listeRuches->currentText();
572  communicationTTN->abonner(rucher[ui->listeRuches->currentIndex()]->getDeviceID());
573  indexRucheSelectionnee = ui->listeRuches->currentIndex();
574  ui->labelRucheSelectionnee->setText("Ruche sélectionnée : " + ui->listeRuches->currentText());
575  ui->labelHorodatage->setText("");
576  ui->lcdTemperatureInterieure->display(0.);
577  ui->lcdTemperatureExterieure->display(0.);
578  ui->lcdHumiditeInterieure->display(0.);
579  ui->lcdHumiditeExterieure->display(0.);
580  ui->lcdPoids->display(0.);
581  ui->lcdPression->display(0.);
582  ui->labelAlerteTemperatureExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
583  ui->labelAlerteTemperatureInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
584  ui->labelAlerteHumiditeExterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
585  ui->labelAlerteHumiditeInterieure->setPixmap(QPixmap(QDir::currentPath() + ""));
586  ui->labelAlertePoids->setPixmap(QPixmap(QDir::currentPath() + ""));
587  ui->labelAlertePression->setPixmap(QPixmap(QDir::currentPath() + ""));
588  }
589 }
595 {
597  {
598  if(indexRucheSelectionnee > -1)
601  }
602  else
603  {
605  }
606 }
613 {
614  QDateTime maintenant;
615  switch (index)
616  {
618  break;
620  qDebug() << Q_FUNC_INFO << "ONGLET_GRAPHIQUES";
621  maintenant = QDateTime::currentDateTime();
622  historique->recupererDonnees(rucher[indexRucheSelectionnee]->getDeviceID(), QString::number(maintenant.time().hour()) + "h");
623  break;
625 
626  break;
627  default:
628  break;
629  }
630 }
636 void IHMPc::journaliser(QString message)
637 {
638  ui->journal->append(message);
639 }
640 
646 {
647  QHBoxLayout *layoutGraphePoids = new QHBoxLayout;
648 
655 
656  graphique = new QChartView(graphePoids);
657  graphique->setRenderHint(QPainter::Antialiasing);
658 
659  ui->layoutGraphiques->addLayout(layoutGraphePoids);
660  layoutGraphePoids->addWidget(graphique);
661 }
662 
668 {
669  courbePoids = new QLineSeries();
670 
671  courbePoids->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Poids</font>"));
672  QPen pen;
673  pen.setColor(QColor(0x99, 0x49, 0x2e));
674  pen.setWidth(2);
675  courbePoids->setPen(pen);
676 
677  graphePoids = new QChart();
678  graphePoids->setBackgroundVisible(false);
679  graphePoids->addSeries(courbePoids);
680  graphePoids->setBackgroundBrush(QColor(0xFFFFFF));
681 
682  QValueAxis *axeXPoids = new QValueAxis;
683  axeXPoids->setRange(0, 23);
684  axeXPoids->setTickCount(24);
685  axeXPoids->setLabelFormat("%02dh");
686  axeXPoids->setTitleText(QString::fromUtf8("Heure"));
687  axeXPoids->setLabelsColor(0xFFFFFF);
688  axeXPoids->setTitleBrush(QColor(0xFFFFFF));
689  graphePoids->addAxis(axeXPoids, Qt::AlignBottom);
690  courbePoids->attachAxis(axeXPoids);
691 
692  QValueAxis *axeYPoids = new QValueAxis;
693  axeYPoids->setRange(0, 50); // définir des constantes !
694  axeYPoids->setLabelFormat("%.2f");
695  axeYPoids->setTitleText(QString::fromUtf8("Poids en Kg"));
696  axeYPoids->setLabelsColor(0xFFFFFF);
697  axeYPoids->setTitleBrush(QColor(0xFFFFFF));
698  graphePoids->addAxis(axeYPoids, Qt::AlignLeft);
699 
700  courbePoids->setPointsVisible(true);
701  courbePoids->setPointLabelsFormat("@yPoint" " ");
702  courbePoids->setPointLabelsVisible(true);
703  courbePoids->attachAxis(axeYPoids);
704 
705  courbePoids->setPointLabelsColor(0xFFFFFF);
706 }
712 {
713  courbePression = new QLineSeries();
714 
715  courbePression->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Pression</font>"));
716  QPen pen;
717  pen.setColor(QColor(Qt::yellow));
718  pen.setWidth(2);
719  courbePression->setPen(pen);
720 
721  graphePression = new QChart();
722  graphePression->setBackgroundVisible(false);
723  graphePression->addSeries(courbePression);
724  graphePression->setBackgroundBrush(QColor(0xFFFFFF));
725 
726  QValueAxis *axeXPression = new QValueAxis;
727  axeXPression->setRange(0, 23);
728  axeXPression->setTickCount(24);
729  axeXPression->setLabelFormat("%02dh");
730  axeXPression->setTitleText(QString::fromUtf8("Heure"));
731  axeXPression->setLabelsColor(0xFFFFFF);
732  axeXPression->setTitleBrush(QColor(0xFFFFFF));
733  graphePression->addAxis(axeXPression, Qt::AlignBottom);
734  courbePression->attachAxis(axeXPression);
735 
736  QValueAxis *axeYPression = new QValueAxis;
737  axeYPression->setRange(900, 1100); // définir des constantes !
738  axeYPression->setLabelFormat("%.2f");
739  axeYPression->setTitleText(QString::fromUtf8("Pression en hPa"));
740  axeYPression->setLabelsColor(0xFFFFFF);
741  axeYPression->setTitleBrush(QColor(0xFFFFFF));
742  graphePression->addAxis(axeYPression, Qt::AlignLeft);
743 
744  courbePression->setPointsVisible(true);
745  courbePression->setPointLabelsFormat("@yPoint" " ");
746  courbePression->setPointLabelsVisible(true);
747  courbePression->attachAxis(axeYPression);
748 
749  courbePression->setPointLabelsColor(0xFFFFFF);
750 }
756 {
757  courbeTemperatureExt = new QLineSeries();
758 
759  courbeTemperatureExt->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Temperature Exterieure</font>"));
760  QPen pen;
761  pen.setColor(QColor(Qt::darkRed));
762  pen.setWidth(2);
763  courbeTemperatureExt->setPen(pen);
764 
765  grapheTemperatureExt = new QChart();
766  grapheTemperatureExt->setBackgroundVisible(false);
768  grapheTemperatureExt->setBackgroundBrush(QColor(0xFFFFFF));
769 
770  QValueAxis *axeXTemperatureExt = new QValueAxis;
771  axeXTemperatureExt->setRange(0, 23);
772  axeXTemperatureExt->setTickCount(24);
773  axeXTemperatureExt->setLabelFormat("%02dh");
774  axeXTemperatureExt->setTitleText(QString::fromUtf8("Heure"));
775  axeXTemperatureExt->setLabelsColor(0xFFFFFF);
776  axeXTemperatureExt->setTitleBrush(QColor(0xFFFFFF));
777  grapheTemperatureExt->addAxis(axeXTemperatureExt, Qt::AlignBottom);
778  courbeTemperatureExt->attachAxis(axeXTemperatureExt);
779 
780  QValueAxis *axeYTemperatureExt = new QValueAxis;
781  axeYTemperatureExt->setRange(-20, 60); // définir des constantes !
782  axeYTemperatureExt->setLabelFormat("%.2f");
783  axeYTemperatureExt->setTitleText(QString::fromUtf8("Temperature Ext. en °C"));
784  axeYTemperatureExt->setLabelsColor(0xFFFFFF);
785  axeYTemperatureExt->setTitleBrush(QColor(0xFFFFFF));
786  grapheTemperatureExt->addAxis(axeYTemperatureExt, Qt::AlignLeft);
787 
788  courbeTemperatureExt->setPointsVisible(true);
789  courbeTemperatureExt->setPointLabelsFormat("@yPoint" " ");
790  courbeTemperatureExt->setPointLabelsVisible(true);
791  courbeTemperatureExt->attachAxis(axeYTemperatureExt);
792 
793  courbeTemperatureExt->setPointLabelsColor(0xFFFFFF);
794 }
800 {
801  courbeTemperatureInt = new QLineSeries();
802 
803  courbeTemperatureInt->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Temperature Interieure</font>"));
804  QPen pen;
805  pen.setColor(QColor(Qt::red));
806  pen.setWidth(2);
807  courbeTemperatureInt->setPen(pen);
808 
809  grapheTemperatureInt = new QChart();
810  grapheTemperatureInt->setBackgroundVisible(false);
812  grapheTemperatureInt->setBackgroundBrush(QColor(0xFFFFFF));
813 
814  QValueAxis *axeXTemperatureInt = new QValueAxis;
815  axeXTemperatureInt->setRange(0, 23);
816  axeXTemperatureInt->setTickCount(24);
817  axeXTemperatureInt->setLabelFormat("%02dh");
818  axeXTemperatureInt->setTitleText(QString::fromUtf8("Heure"));
819  axeXTemperatureInt->setLabelsColor(0xFFFFFF);
820  axeXTemperatureInt->setTitleBrush(QColor(0xFFFFFF));
821  grapheTemperatureInt->addAxis(axeXTemperatureInt, Qt::AlignBottom);
822  courbeTemperatureInt->attachAxis(axeXTemperatureInt);
823 
824  QValueAxis *axeYTemperatureInt = new QValueAxis;
825  axeYTemperatureInt->setRange(-20, 60); // définir des constantes !
826  axeYTemperatureInt->setLabelFormat("%.2f");
827  axeYTemperatureInt->setTitleText(QString::fromUtf8("Temperature Int. en °C"));
828  axeYTemperatureInt->setLabelsColor(0xFFFFFF);
829  axeYTemperatureInt->setTitleBrush(QColor(0xFFFFFF));
830  grapheTemperatureInt->addAxis(axeYTemperatureInt, Qt::AlignLeft);
831 
832  courbeTemperatureInt->setPointsVisible(true);
833  courbeTemperatureInt->setPointLabelsFormat("@yPoint" " ");
834  courbeTemperatureInt->setPointLabelsVisible(true);
835  courbeTemperatureInt->attachAxis(axeYTemperatureInt);
836 
837  courbeTemperatureInt->setPointLabelsColor(0xFFFFFF);
838 }
844 {
845  courbeHumiditeExt = new QLineSeries();
846 
847  courbeHumiditeExt->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Humidite Exterieure</font>"));
848  QPen pen;
849  pen.setColor(QColor(Qt::darkBlue));
850  pen.setWidth(2);
851  courbeHumiditeExt->setPen(pen);
852 
853  grapheHumiditeExt = new QChart();
854  grapheHumiditeExt->setBackgroundVisible(false);
856  grapheHumiditeExt->setBackgroundBrush(QColor(0xFFFFFF));
857 
858  QValueAxis *axeXHumiditeExt = new QValueAxis;
859  axeXHumiditeExt->setRange(0, 23);
860  axeXHumiditeExt->setTickCount(24);
861  axeXHumiditeExt->setLabelFormat("%02dh");
862  axeXHumiditeExt->setTitleText(QString::fromUtf8("Heure"));
863  axeXHumiditeExt->setLabelsColor(0xFFFFFF);
864  axeXHumiditeExt->setTitleBrush(QColor(0xFFFFFF));
865  grapheHumiditeExt->addAxis(axeXHumiditeExt, Qt::AlignBottom);
866  courbeHumiditeExt->attachAxis(axeXHumiditeExt);
867 
868  QValueAxis *axeYHumiditeExt = new QValueAxis;
869  axeYHumiditeExt->setRange(0, 100); // définir des constantes !
870  axeYHumiditeExt->setLabelFormat("%.2f");
871  axeYHumiditeExt->setTitleText(QString::fromUtf8("Humidite Ext. en %"));
872  axeYHumiditeExt->setLabelsColor(0xFFFFFF);
873  axeYHumiditeExt->setTitleBrush(QColor(0xFFFFFF));
874  grapheHumiditeExt->addAxis(axeYHumiditeExt, Qt::AlignLeft);
875 
876  courbeHumiditeExt->setPointsVisible(true);
877  courbeHumiditeExt->setPointLabelsFormat("@yPoint" " ");
878  courbeHumiditeExt->setPointLabelsVisible(true);
879  courbeHumiditeExt->attachAxis(axeYHumiditeExt);
880 
881  courbeHumiditeExt->setPointLabelsColor(0xFFFFFF);
882 }
888 {
889  courbeHumiditeInt = new QLineSeries();
890 
891  courbeHumiditeInt->setName(QString::fromUtf8("<font color=\"#FFFFFF\">Humidite Interieure</font>"));
892  QPen pen;
893  pen.setColor(QColor(Qt::blue));
894  pen.setWidth(2);
895  courbeHumiditeInt->setPen(pen);
896 
897  grapheHumiditeInt = new QChart();
898  grapheHumiditeInt->setBackgroundVisible(false);
900  grapheHumiditeInt->setBackgroundBrush(QColor(0xFFFFFF));
901 
902  QValueAxis *axeXHumiditeInt = new QValueAxis;
903  axeXHumiditeInt->setRange(0, 23);
904  axeXHumiditeInt->setTickCount(24);
905  axeXHumiditeInt->setLabelFormat("%02dh");
906  axeXHumiditeInt->setTitleText(QString::fromUtf8("Heure"));
907  axeXHumiditeInt->setLabelsColor(0xFFFFFF);
908  axeXHumiditeInt->setTitleBrush(QColor(0xFFFFFF));
909  grapheHumiditeInt->addAxis(axeXHumiditeInt, Qt::AlignBottom);
910  courbeHumiditeInt->attachAxis(axeXHumiditeInt);
911 
912  QValueAxis *axeYHumiditeInt = new QValueAxis;
913  axeYHumiditeInt->setRange(0, 100); // définir des constantes !
914  axeYHumiditeInt->setLabelFormat("%.2f");
915  axeYHumiditeInt->setTitleText(QString::fromUtf8("Humidite Int. en %"));
916  axeYHumiditeInt->setLabelsColor(0xFFFFFF);
917  axeYHumiditeInt->setTitleBrush(QColor(0xFFFFFF));
918  grapheHumiditeInt->addAxis(axeYHumiditeInt, Qt::AlignLeft);
919 
920  courbeHumiditeInt->setPointsVisible(true);
921  courbeHumiditeInt->setPointLabelsFormat("@yPoint" " ");
922  courbeHumiditeInt->setPointLabelsVisible(true);
923  courbeHumiditeInt->attachAxis(axeYHumiditeInt);
924 
925  courbeHumiditeInt->setPointLabelsColor(0xFFFFFF);
926 }
932 {
933  qDebug() << Q_FUNC_INFO << "index" << ui->listeMesuresGraphiques->currentIndex();
934  switch((TypeGraphique)ui->listeMesuresGraphiques->currentIndex())
935  {
938  break;
941  break;
944  break;
947  break;
950  break;
953  break;
954  }
955 }
961 {
962  QDateTime maintenant = QDateTime::currentDateTime();
963  historique->recupererDonnees(rucher[indexRucheSelectionnee]->getDeviceID(), QString::number(maintenant.time().hour()) + "h");
964 }
970 {
971  QVector<QStringList> mesures = historique->getMesuresPoids();
972  qDebug() << Q_FUNC_INFO << "Nb mesures poids" << mesures.size();
973  qDebug() << Q_FUNC_INFO << "mesures poids" << mesures;
974 
975  courbePoids->clear();
976  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
977  {
978  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
979  courbePoids->append((*it).at(0).toInt(), (*it).at(1).toDouble());
980  }
981 
982  graphique->setChart(graphePoids);
983  graphique->update();
984 }
990 {
991  QVector<QStringList> mesures = historique->getMesuresPression();
992  qDebug() << Q_FUNC_INFO << "Nb mesures pression" << mesures.size();
993  qDebug() << Q_FUNC_INFO << "mesures pression" << mesures;
994 
995  courbePression->clear();
996  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
997  {
998  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
999  courbePression->append((*it).at(0).toInt(), (*it).at(1).toDouble());
1000  }
1001 
1002  graphique->setChart(graphePression);
1003  graphique->update();
1004 }
1010 {
1011  QVector<QStringList> mesures = historique->getMesuresTemperatureExterieure();
1012  qDebug() << Q_FUNC_INFO << "Nb mesures temperature exterieure" << mesures.size();
1013  qDebug() << Q_FUNC_INFO << "mesures termperature exterieure" << mesures;
1014 
1015  courbeTemperatureExt->clear();
1016  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
1017  {
1018  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
1019  courbeTemperatureExt->append((*it).at(0).toInt(), (*it).at(1).toDouble());
1020  }
1021 
1022  graphique->setChart(grapheTemperatureExt);
1023  graphique->update();
1024 }
1030 {
1031  QVector<QStringList> mesures = historique->getMesuresTemperatureInterieure();
1032  qDebug() << Q_FUNC_INFO << "Nb mesures temperature interieure" << mesures.size();
1033  qDebug() << Q_FUNC_INFO << "mesures termperature interieure" << mesures;
1034 
1035  courbeTemperatureInt->clear();
1036  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
1037  {
1038  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
1039  courbeTemperatureInt->append((*it).at(0).toInt(), (*it).at(1).toDouble());
1040  }
1041 
1042  graphique->setChart(grapheTemperatureInt);
1043  graphique->update();
1044 }
1050 {
1051  QVector<QStringList> mesures = historique->getMesuresHumiditeExterieure();
1052  qDebug() << Q_FUNC_INFO << "Nb mesures humidite exterieure" << mesures.size();
1053  qDebug() << Q_FUNC_INFO << "mesures humidite exterieure" << mesures;
1054 
1055  courbeHumiditeExt->clear();
1056  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
1057  {
1058  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
1059  courbeHumiditeExt->append((*it).at(0).toInt(), (*it).at(1).toDouble());
1060  }
1061 
1062  graphique->setChart(grapheHumiditeExt);
1063  graphique->update();
1064 }
1070 {
1071  QVector<QStringList> mesures = historique->getMesuresHumiditeInterieure();
1072  qDebug() << Q_FUNC_INFO << "Nb mesures humidite interieure" << mesures.size();
1073  qDebug() << Q_FUNC_INFO << "mesures humidite interieure" << mesures;
1074 
1075  courbeHumiditeInt->clear();
1076  for(QVector<QStringList>::iterator it = mesures.begin(); it != mesures.end(); it++)
1077  {
1078  //qDebug() << Q_FUNC_INFO << "heure" << (*it).at(0).toInt() << "mesure" << (*it).at(1).toDouble();
1079  courbeHumiditeInt->append((*it).at(0).toInt(), (*it).at(1).toDouble());
1080  }
1081 
1082  graphique->setChart(grapheHumiditeInt);
1083  graphique->update();
1084 }
bool abonner(QString deviceID)
Méthode qui abonne le client Mqtt à un topic , à partir du deviceID.
#define HUMIDITE_INTERIEURE_MAX
Definition: ihmpc.h:52
void deconnecter()
Méthode qui déconnecte le client Mqtt.
#define TEMPERATURE_EXTERIEURE_MAX
Definition: ihmpc.h:46
La déclaration de la classe Historique.
QChart * graphePoids
la représentation du graphe
Definition: ihmpc.h:93
La déclaration de la classe Communication.
void setPressionMax(double pressionMax)
Methode qui change la pression maximale.
Definition: alertes.cpp:258
#define HUMIDITE_EXTERIEURE_MIN
Definition: ihmpc.h:51
IHMPc(QWidget *parent=nullptr)
Constructeur de la classe IHMPc.
Definition: ihmpc.cpp:29
Ui::IHMPc * ui
Association vers l&#39;interface utilisateur (Qt Designer)
Definition: ihmpc.h:85
QString getPassword() const
Methode qui retourne le mot de passe.
QChart * grapheHumiditeExt
la représentation du graphe
Definition: ihmpc.h:102
Definition: ruche.h:15
Historique * historique
Pointeur sur l&#39;objet Historique.
Definition: ihmpc.h:87
bool verifierHumiditeExterieure(double humidite) const
Definition: alertes.cpp:111
QChart * grapheTemperatureInt
la représentation du graphe
Definition: ihmpc.h:100
void gererConnexionTTN()
Methode qui permet la gestion de la connexion au TTN.
Definition: ihmpc.cpp:594
QChart * grapheTemperatureExt
la représentation du graphe
Definition: ihmpc.h:98
bool verifierPoids(double poids) const
Methode qui verifie le poids.
Definition: alertes.cpp:140
void selectionnerRuche()
Méthode qui selectionne la ruche (s&#39;abonne) et se desabonne de l&#39;ancienne : renitialisation des valeu...
Definition: ihmpc.cpp:565
void initialiserGraphiqueHumiditeInterieure()
Méthode qui initialise le graphique pour l&#39;humidite interieure.
Definition: ihmpc.cpp:887
void setTemperatureInterieureMax(double temperatureInterieureMax)
Methode qui change la temperature interieure maximale.
Definition: alertes.cpp:178
QLineSeries * courbeTemperatureExt
Les données sous forme de courbe.
Definition: ihmpc.h:97
TypeGraphique
Définit les différents types de graphiques.
Definition: ihmpc.h:36
void configurerAlertes()
Methode qui permet la configuration des seuils d&#39;alertes.
Definition: ihmpc.cpp:433
Definition: ihmpc.h:60
void afficherTemperatureInterieure(double temperatureInterieure=0., QString uniteTemperature=QString(" °C")) const
Méthode qui affiche la temperature interieure.
Definition: ihmpc.cpp:70
void initialiserGraphiquePoids()
Méthode qui initialise le graphique pour le poids.
Definition: ihmpc.cpp:667
QString getHorodatage() const
Methode qui retourne la valeur de l&#39;horodatage.
void initialiserGraphiqueHumiditeExterieure()
Méthode qui initialise le graphique pour l&#39;humidite exterieure.
Definition: ihmpc.cpp:843
QVector< QStringList > getMesuresHumiditeExterieure() const
Methode qui retourne un conteneur dynamique, contenant les mesures de l&#39;humidite exterieure.
Definition: historique.cpp:115
QVector< QStringList > getMesuresTemperatureExterieure() const
Methode qui retourne un conteneur dynamique, contenant les mesures de la temperature exterieure...
Definition: historique.cpp:97
void desabonner(QString deviceID)
Méthode qui désabonne le client Mqtt , à partir du deviceID.
void initialiserGestionEvenements()
Méthode qui intialise les évenements.
Definition: ihmpc.cpp:333
void afficherHumiditeExterieure(double humiditeExterieure=0., QString uniteHumidite=QString(" %")) const
Méthode qui affiche l&#39;humidite interieure.
Definition: ihmpc.cpp:109
#define PRESSION_MAX
Definition: ihmpc.h:54
QLineSeries * courbeHumiditeExt
Les données sous forme de courbe.
Definition: ihmpc.h:101
La déclaration de la classe IHMPc.
void afficherGraphiqueHumiditeInterieure()
Méthode qui affiche le graphique pour l&#39;humidite interieure.
Definition: ihmpc.cpp:1069
bool verifierTemperatureInterieure(double temperature) const
Methode qui verifie la temperature interieure.
Definition: alertes.cpp:93
double getTemperatureInterieure() const
Methode qui retourne la valeur de la temperature interieure.
void afficherNouvellesMesures(MesureRuche mesure)
Méthode qui affiche les nouvelles mesures.
Definition: ihmpc.cpp:546
void creerRucher()
Méthode qui créer un rucher.
Definition: ihmpc.cpp:311
QString getHostname() const
Methode qui retourne le nom d&#39;hote.
void initialiserIHM()
Méthode qui initialise l&#39;IHM.
Definition: ihmpc.cpp:296
L&#39;onglet de visualisation des graphiques des ruches.
Definition: ihmpc.h:28
void afficherGraphiquePression()
Méthode qui affiche le graphique pour la pression.
Definition: ihmpc.cpp:989
void initialiserAlertes()
Methode qui initialise les seuils d&#39;alertes.
Definition: ihmpc.cpp:359
QVector< QStringList > getMesuresTemperatureInterieure() const
Methode qui retourne un conteneur dynamique, contenant les mesures de la temperature interieure...
Definition: historique.cpp:106
La déclaration de la classe Ruche.
void afficherPression(double pression=0., QString unitePression=QString(" hPa")) const
Méthode qui affiche la pression.
Definition: ihmpc.cpp:135
void ouvrirFenetreAjouter()
Méthode qui ouvre une fenetre de dialogue pour ajouter une ruche : nom et deviceID.
Definition: ihmpc.cpp:379
void connecter()
Méthode qui connecte le client Mqtt (par défaut) et permet la récupération du message (à l&#39;aide de la...
void selectionnerGraphique()
Methode qui gere la selection du graphique.
Definition: ihmpc.cpp:931
void afficherAlerteTemperatureExterieure(double temperature)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour la temperature exterieure.
Definition: ihmpc.cpp:199
#define PRESSION_MIN
Definition: ihmpc.h:55
void afficherAlertePoids(double poids)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour le poids.
Definition: ihmpc.cpp:263
Déclaration de la classe Historique.
Definition: historique.h:26
void setHumiditeExterieureMax(double humiditeExterieureMax)
Methode qui change l&#39;humidite exterieure maximale.
Definition: alertes.cpp:238
void setPressionMin(double pressionMin)
Methode qui change la pression minimale.
Definition: alertes.cpp:268
void afficherEtatDeconnecte()
Méthode qui affiche l&#39;état de la connexion (deconnecté), à partir d&#39;une image en haut à droite...
Definition: ihmpc.cpp:160
void initialiserGraphiqueTemperatureInterieure()
Méthode qui initialise le graphique pour la temperature interieure.
Definition: ihmpc.cpp:799
bool estConnecte() const
Méthode qui retourne une valeur booléene true si le client Mqtt est connecté
void afficherGraphiqueTemperatureInterieure()
Méthode qui affiche le graphique pour la temperature interieure.
Definition: ihmpc.cpp:1029
void setPoidsMin(double poidsMin)
Methode qui change le poids minimale.
Definition: alertes.cpp:288
void recupererDonnees(QString deviceID, QString duree="")
Methode qui recupère toutes les donnees (mesures des capteurs) de la ruche selectionnee (deviceID) ...
Definition: historique.cpp:46
L&#39;onglet de visualisation des mesures des ruches.
Definition: ihmpc.h:27
QVector< QStringList > getMesuresPoids() const
Methode qui retourne un conteneur dynamique, contenant les mesures du poids.
Definition: historique.cpp:79
Communication * communicationTTN
Pointeur sur l&#39;objet Communication.
Definition: ihmpc.h:86
double getHumiditeInterieure() const
Methode qui retourne la valeur de l&#39;humidite interieure.
void initialiserGraphiqueTemperatureExterieure()
Méthode qui initialise le graphique pour la temperature exterieure.
Definition: ihmpc.cpp:755
void afficherAlerteHumiditeExterieure(double humidite)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour l&#39;humidite exterieure.
Definition: ihmpc.cpp:231
void afficherTemperatureExterieure(double temperatureExterieure=0., QString uniteTemperature=QString(" °C")) const
Méthode qui affiche la temperature exterieure.
Definition: ihmpc.cpp:83
QLineSeries * courbeHumiditeInt
Les données sous forme de courbe.
Definition: ihmpc.h:103
void afficherPoids(double poids=0., QString unitePoids=QString(" Kg")) const
Méthode qui affiche le poids.
Definition: ihmpc.cpp:122
void initialiserGraphiquePression()
Méthode qui initialise le graphique pour la pression.
Definition: ihmpc.cpp:711
La déclaration de la classe Alertes.
Déclaration de la classe IHMPc.
Definition: ihmpc.h:76
void creerGraphique()
Méthode qui crée et initialise la vue pour les graphiques.
Definition: ihmpc.cpp:645
void afficherGraphiqueTemperatureExterieure()
Méthode qui affiche le graphique pour la temperature exterieure.
Definition: ihmpc.cpp:1009
void afficherGraphiqueHumiditeExterieure()
Méthode qui affiche le graphique pour l&#39;humidite exterieure.
Definition: ihmpc.cpp:1049
#define HUMIDITE_EXTERIEURE_MAX
Definition: ihmpc.h:50
void setTemperatureInterieureMin(double temperatureInterieureMin)
Methode qui change la temperature interieure minimum.
Definition: alertes.cpp:188
double getTemperatureExterieure() const
Methode qui retourne la valeur de la temperature exterieure.
QVector< QStringList > getMesuresHumiditeInterieure() const
Methode qui retourne un conteneur dynamique, contenant les mesures de l&#39;humidite interieure.
Definition: historique.cpp:124
void setTemperatureExterieureMin(double temperatureExterieureMin)
Methode qui change la temperature exterieure minimale.
Definition: alertes.cpp:208
#define POIDS_MAX
Definition: ihmpc.h:56
double getPression() const
Methode qui retourne la valeur de la pression.
void afficherAlertePression(double pression)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour la pression.
Definition: ihmpc.cpp:279
void setHumiditeInterieureMin(double humiditeInterieureMin)
Methode qui change l&#39;humidite interieure minimale.
Definition: alertes.cpp:228
void setAuthentification(QString url, QString cle)
Methode qui modifie l&#39;URL et la clé
Definition: historique.cpp:34
void afficherAlerteTemperatureInterieure(double temperature)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour la temperature interieure.
Definition: ihmpc.cpp:215
void supprimerRuche()
Méthode qui supprime une ruche, dans la listedeRucheSelectionnee et dans le vector rucher<> ...
Definition: ihmpc.cpp:411
void afficherEtatConnecte()
Méthode qui affiche l&#39;état de la connexion (connecté), à partir d&#39;une image en haut à droite...
Definition: ihmpc.cpp:146
void afficherAlerteHumiditeInterieure(double humidite)
Methode qui affiche (ou pas) un temoin lumineu d&#39;alerte pour l&#39;humidite interieure.
Definition: ihmpc.cpp:247
QString getUsername() const
Methode qui retourne le nom d&#39;utilisateur.
#define HUMIDITE_INTERIEURE_MIN
Definition: ihmpc.h:53
QVector< QStringList > getMesuresPression() const
Methode qui retourne un conteneur dynamique, contenant les mesures de la pression.
Definition: historique.cpp:88
Alertes alertes
Definition: ihmpc.h:106
void afficherHorodatage(QString horodatage)
Méthode qui affiche l&#39;horodatage.
Definition: ihmpc.cpp:536
void setHumiditeExterieureMin(double humiditeExterieureMin)
Methode qui change l&#39;humidite exterieure minimale.
Definition: alertes.cpp:248
void configurerConnexionTTN()
Methode qui permet la configuration de l&#39;acces TTN.
Definition: ihmpc.cpp:510
QChartView * graphique
widget pour afficher le graphe
Definition: ihmpc.h:92
int indexRucheSelectionnee
L&#39;index courant de la ruche sélectionnée.
Definition: ihmpc.h:89
QLineSeries * courbeTemperatureInt
Les données sous forme de courbe.
Definition: ihmpc.h:99
L&#39;onglet de visualisation du log.
Definition: ihmpc.h:29
void verifierAlertes(MesureRuche mesure)
Methode qui verifie si les seuils sont depasses.
Definition: ihmpc.cpp:185
QLineSeries * courbePression
Les données sous forme de courbe.
Definition: ihmpc.h:96
void setTemperatureExterieureMax(double temperatureExterieureMax)
Methode qui change la temperature exterieure maximale.
Definition: alertes.cpp:198
#define POIDS_MIN
Definition: ihmpc.h:57
bool verifierPression(double pression) const
Definition: alertes.cpp:157
void setPoidsMax(double poidsMax)
Methode qui change le poids maximale.
Definition: alertes.cpp:278
~IHMPc()
Destructeur de la classe IHMPc.
Definition: ihmpc.cpp:55
#define TEMPERATURE_INTERIEURE_MAX
Definition: ihmpc.h:48
QChart * grapheHumiditeInt
la représentation du graphe
Definition: ihmpc.h:104
void afficherGraphiquePoids()
Méthode qui affiche le graphique pour le poids.
Definition: ihmpc.cpp:969
#define TEMPERATURE_EXTERIEURE_MIN
Definition: ihmpc.h:47
bool verifierTemperatureExterieure(double temperature) const
Definition: alertes.cpp:76
void reconnecter()
Méthode qui déconnecte puis connecte le client Mqtt.
void rechargerGraphique()
Methode qui recharge le graphique à l&#39;heure actuelle.
Definition: ihmpc.cpp:960
void journaliser(QString message)
Methode qui ajoute le message dans l&#39;onglet journal.
Definition: ihmpc.cpp:636
void afficherHumiditeInterieure(double humiditeInterieure=0., QString uniteHumidite=QString(" %")) const
Méthode qui affiche l&#39;humidite interieure.
Definition: ihmpc.cpp:96
QLineSeries * courbePoids
Les données sous forme de courbe.
Definition: ihmpc.h:94
#define TEMPERATURE_INTERIEURE_MIN
Definition: ihmpc.h:49
bool verifierHumiditeInterieure(double humidite) const
Methode qui verifie l&#39;humidite interieure.
Definition: alertes.cpp:128
double getPoids() const
Methode qui retourne la valeur du poids.
double getHumiditeExterieure() const
Methode qui retourne la valeur de l&#39;humidite exterieure.
QChart * graphePression
la représentation du graphe
Definition: ihmpc.h:95
void gererChangementOnglet(int)
Methode qui gere le changement d&#39;onglet selon l&#39;index.
Definition: ihmpc.cpp:612
void setHumiditeInterieureMax(double humiditeInterieureMax)
Methode qui change l&#39;humidite interieure maximale.
Definition: alertes.cpp:218
QVector< Ruche * > rucher
Les ruches de l&#39;apiculteur.
Definition: ihmpc.h:88