Discussion :

[abii93200]

Bonjour à tous,

Mon projet a pour but de developper un systeme automatisée permettant de gérer des conditions climatiques prédéfinies ou forcées à l'intérieur d'une serre de culture.
Je suis responsable de la partie developpement du software et je bloque sur la gestion des plages :
Le système doit permettre de définir 7 journées types (1H de résolution)
J'ai choisi de coder ça sous Design et j'aimerais qu'a l'appui du bouton enregistrer : l'ensemble des valeurs des spins box de l'onglet actif sois récupérer quelque part afin que je puisse les envoyé à une SGBD apres.

Pour l'envoie à la SGBD je n'ai pas de soucis tous est pret me reste juste à recupérer les valeurs de la config de la journée.
Je vous met un screen de ce que j'ai fais sous Design.

Merci de votre aide.

[koala01]

Salut,

Une petite précision avant de commencer : je ne suis pas fan du tout du designer. Lorsque je peux m'en passer, j'aime autant créer mes propres widgets par programmation. C'est ce que je vais mettre en avant ici

La première chose que je ferais, étant donné que l'on a besoin des même éléments graphique pour toutes les plages horaires, c'est de créer un widget particulier qui me les fournirait, sous une forme qui pourrait ressembler à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class TimeSlot : public QWidget{
    Q_OBJECT
public:
    TimeSlot(int hour);
    /* parce qu'il faudra bien sauvegarder les informations :D */
    void save();
private:
    QSpinBox * temperature;
    QSpinBox * humidity;
    QSpinBox * luminosity;
};

dont l'implémentation pourrait ressembler à quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
TimSlot::TimeSlot(int hour){
     QLabel * label = new QLabel(QString::number(hour));
    temperature = new QSpinBox;
    humidity = new QSpinBox;
    luminosity = new QSpinBox;
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(label);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}
void TimeSlot::save(){
    /* ce qu'il faudra faire ici */
}

Et, parce que j'aime bien me faciliter la vie, je créerais sans doute un deuxième widget pour les "en-têtes " de colonnes. Il serait sans doute encore plus simple, vu qu'il prendrait une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class ColumnHeaders : public QWidget{
    Q_OBJECT
public:
    ColumnHeaders();
};

et l'implémentation ressemblerait à quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
ColumnHeaders::ColumnHeaders(){
    QLabel * hour = new QLabel(tr("Heure :"));
    QLabel * temperature = new QLabel(tr("Température °"));
    QLabel * humidity = new QLabel(tr("Humidité %"));
    QLabel * luminosity = new QLabel(tr("Luminosité %"));
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(hour);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}

(NOTA : j'ai utilisé tr pour le cas où tu envisagerais de traduire ton interface graphique dans d'autres langues )

A l'aide de ces deux widgets, j'aurais créé un troisième qui représentera le planning d'une journée sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Planning : public QWidget{
    Q_OBJECT
public:
    Planning();
    /* parce que l'on veut pouvoir sauvegarder le planning entier */
    void save();
private:
    /* parce que pour sauvegarder le planning, il faut pouvoir accéder à 
     * toutes les plages horraires
     */
    QList<TimeSlot * > allSlots;
};

Avec une implémentation qui prendrait une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
Planning::Planning(){
    QVBoxLayout * layout = new QVBoxLayout;
    /* d'abord, les en-têtes */
    ColumnHeaders * headers = new ColumnHeaders;
    layout->addWidget(headers);
    /* ensuite, les 24 plages horaires */
    for(int i = 0; i<24; ++i){
        TimeSlot * temp = new TimeSlot(i);
         layout->addWidget(temp);
         allSlots.append(temp);
    }
    setLayout(layout);
}
void Planning::save(){
    for(auto * it : allSlots)
        it->save();
}

Dans "l'élément final" qui affiche le planning et qui propose l'enregistrement, je n'aurais donc plus eu qu'à créer un planning et à connecter le signal clicked du bouton "Enregistrer" à un slot qui aurait pu prendre lla forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
void MyForm::onSaveClicked(){
    planning->save()
}

Et le tout m'aurais demandé... 15 minutes de travail (maxi )

[abii93200]

Bonjour Koala merci de ta réponse.

Je n'ai pas un super niveau en programmation QT et c'est pour cela que j'ai choisi designer qui me paraissait plus simple ^^
De plus je ne vois pas comment afficher le planning et obtenir les configuration que l'utilisateur a rentré dans les SPINBOX ?
voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
#include <QApplication>
#include <QtWidgets>
 
class TimeSlot : public QWidget{
    Q_OBJECT
public:
    TimeSlot(int hour);
    /* parce qu'il faudra bien sauvegarder les informations :D */
    void save();
private:
    QSpinBox * temperature;
    QSpinBox * humidity;
    QSpinBox * luminosity;
};
TimeSlot::TimeSlot(int hour){
    QLabel * label = new QLabel(QString::number(hour));
    temperature = new QSpinBox;
    humidity = new QSpinBox;
    luminosity = new QSpinBox;
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(label);
    layout->addWidget(temperature);
    layout->addWidget(luminosity);
    setLayout(layout);
}
void TimeSlot::save(){
    /* ce qu'il faudra faire ici */
}
class ColumnHeaders : public QWidget{
    Q_OBJECT
public:
    ColumnHeaders();
};
 
 
ColumnHeaders::ColumnHeaders(){
    QLabel * hour = new QLabel(tr("Heure :"));
    QLabel * temperature = new QLabel(tr("Température °"));
    QLabel * humidity = new QLabel(tr("Humidité %"));
    QLabel * luminosity = new QLabel(tr("Luminosité %"));
    QHBoxLayout *layout = new QHBoxLayout;
    layout->addWidget(humidity);
    layout->addWidget(temperature);
    layout->addWidget(luminosity);
    setLayout(layout);
}
class Planning : public QWidget{
    Q_OBJECT
public:
    Planning();
    /* parce que l'on veut pouvoir sauvegarder le planning entier */
    void save();
private:
    /* parce que pour sauvegarder le planning, il faut pouvoir accéder à
     * toutes les plages horraires
     */
    QList<TimeSlot * > allSlots;
};
Planning::Planning(){
    QVBoxLayout * layout = new QVBoxLayout;
    /* d'abord, les en-têtes */
    ColumnHeaders * headers = new ColumnHeaders;
    layout->addWidget(headers);
    /* ensuite, les 24 plages horaires */
    for(int i = 0; i<24; ++i){
        TimeSlot * temp = new TimeSlot(i);
         layout->addWidget(temp);
         allSlots.append(temp);
    }
    setLayout(layout);
}
void Planning::save(){
    for(auto *it : allSlots)
        it->save;
}
 
int main(int argc, char *argv[])
{
 
    QApplication a(argc, argv);
 
    Planning w;
    w.show();
 
    return a.exec();
}

[koala01]

De plus je ne vois pas comment afficher le planning et obtenir les configuration que l'utilisateur a rentré dans les SPINBOX ?

C'est justement là toute la beauté du système de parent/enfants de Qt: tu n'as pas à t'en inquiéter!!!

Chaque widget est prévu pour afficher le contenu de son layout, quel qu'il soit.

Comme je créer systématiquement un layout (dans TimeSlot, dans ColumnsHeaders et dans Planning), dans lequel je rajoute des widgets et que je défini comme layout pour la classe en question, ils seront forcément affichés

Du coup, tu pourrais tout aussi bien afficher le planning avec un code aussi simple que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#include "planning.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Planning p;
    p.show();
 
    return a.exec();
}

J'ai, pour l'exemple, réduit le nombre de plages à 12 (pour ne pas faire une image trop grande), et j'ai obtenu ceci:

Avoue que c'est génial, non ?

Ensuite, rien ne t'empêche de créer un widget qui regroupe ton planning et un bouton (pour lequel tu connecterait le signal clicked() à la fonction save() de ton planning), puis de rajouter ce widget dans un QTabWidget, et d'afficher ce QTabWidget "perso" (ou d'utiliser ce QTabWidget comme widget central dans une QMainWindow). Et le tour serait joué

[koala01]

Allez, comme je suis vraiment trop sympa, j'ai même créer le projet en entier, qui sauvegarde les données au format csv (dont le nom est config<Numéro de config>.csv ), et je te l'ai mis sur github

J'ai un peu modifié la mise en page, car 24 lignes de plages horaires, je trouvais que cela donnait vraiment un résultat un peu trop "haut"... Mais tout est là et le résultat ressemble à ceci:

[abii93200]

Comme je créer systématiquement un layout (dans TimeSlot, dans ColumnsHeaders et dans Planning), dans lequel je rajoute des widgets et que je défini comme layout pour la classe en question, ils seront forcément affichés

Ensuite, rien ne t'empêche de créer un widget qui regroupe ton planning et un bouton

Du coup je dois rajouter un layout dans le nouveau widget que je vais crée ?

C'est bon j'arrive à afficher le planning ca progresse
Une fois les configurations rentrés et que le bouton enregistrer a été appuyé je dois envoyé cela à une BDD au travers de datagram UDP cela ce fera donc dans la fonction save() ?
J'ai deja mon sender de pret
J'ai crée un nouveau Widget pour regrouper le planning et le bouton mais je sais pas trop comment faire :/
De plus je n'arrive pas a utiliser la fonction save pour le connect du bouton enregistrer je te met mon code :
MERCI !!!

.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class TimeSlot : public QWidget{
    Q_OBJECT
public:
    TimeSlot(int hour);
    /* parce qu'il faudra bien sauvegarder les informations :D */
    void save();
private:
    QSpinBox * temperature;
    QSpinBox * humidity;
    QSpinBox * luminosity;
};
 
 
class ColumnHeaders : public QWidget{
    Q_OBJECT
public:
    ColumnHeaders();
};
 
class Planning : public QWidget{
    Q_OBJECT
public:
    Planning();
    /* parce que l'on veut pouvoir sauvegarder le planning entier */
    void save();
private:
    /* parce que pour sauvegarder le planning, il faut pouvoir accéder à
     * toutes les plages horraires
     */
    QList<TimeSlot * > allSlots;
};
class Planningetbouton : public QWidget{
    Q_OBJECT
    public
 
 
    private:
    QPushButton *Enregistrer;
 
    private slots:
    void enregistrer();
}

.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include "mainwindow.h"
 
TimeSlot::TimeSlot(int hour){
     QLabel * label = new QLabel(QString::number(hour));
    temperature = new QSpinBox;
    humidity = new QSpinBox;
    luminosity = new QSpinBox;
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(label);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}
void TimeSlot::save()
{
    /* ce qu'il faudra faire ici */
}
 
 
    ColumnHeaders::ColumnHeaders(){
    QLabel * hour = new QLabel(tr("Heure :"));
    QLabel * temperature = new QLabel(tr("Température °"));
    QLabel * humidity = new QLabel(tr("Humidité %"));
    QLabel * luminosity = new QLabel(tr("Luminosité %"));
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(hour);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}
 
    Planning::Planning(){
    QVBoxLayout * layout = new QVBoxLayout;
    /* d'abord, les en-têtes */
    ColumnHeaders * headers = new ColumnHeaders;
    layout->addWidget(headers);
    /* ensuite, les 24 plages horaires */
    for(int i = 0; i<24; ++i){
        TimeSlot * temp = new TimeSlot(i);
         layout->addWidget(temp);
         allSlots.append(temp);
    }
    setLayout(layout);
}
void Planning::save()
{
    for(auto * it : allSlots)
        it->save();
}
Planningetbouton::Planningetbouton()
{
    QPushButton *Enregistrer = new QPushButton;
 
}
 
void Planningetbouton::enregistrer()
{
    connect(Enregistrer,SIGNAL(clicked()),this,SLOT(save()));
}

[abii93200]

Franchement tu est vraiment au top c'est super cool de ta part !!
Je test ca et je te dis !!! MERCI MERCI MERCI deja

[Pyramidev]

+1 pour le partage du code sur GitHub, mais je n'approuve pas ta gestion de la mémoire.

Par exemple, à la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "columnheader.h"
#include <QLabel>
#include <QHBoxLayout>
ColumnHeader::ColumnHeader(QWidget *parent) : QWidget(parent)
{
    QLabel * hour = new QLabel(tr("Heure :"));
    QLabel * temperature = new QLabel(tr("Température °"));
    QLabel * humidity = new QLabel(tr("Humidité %"));
    QLabel * luminosity = new QLabel(tr("Luminosité %"));
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(hour);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}

j'aurais écrit quelque chose comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include "columnheader.h"
 
#include <QHBoxLayout>
#include <QLabel>
 
#include <memory>
 
ColumnHeader::ColumnHeader(QWidget* parent) : QWidget(parent)
{
	auto hour        = std::make_unique<QLabel>(tr("Heure :"          ));
	auto temperature = std::make_unique<QLabel>(tr("Température (°) :"));
	auto humidity    = std::make_unique<QLabel>(tr("Humidité (%) :"   ));
	auto luminosity  = std::make_unique<QLabel>(tr("Luminosité (%) :" ));
	auto layout      = std::make_unique<QHBoxLayout>();
	layout->addWidget(hour       .release());
	layout->addWidget(temperature.release());
	layout->addWidget(humidity   .release());
	layout->addWidget(luminosity .release());
	setLayout(layout.release());
}

ou bien, plus simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "columnheader.h"
 
#include <QHBoxLayout>
#include <QLabel>
 
#include <memory>
 
ColumnHeader::ColumnHeader(QWidget* parent) : QWidget(parent)
{
	auto layoutUptr = std::make_unique<QHBoxLayout>();
	auto& layout = *layoutUptr;
	layout.addWidget(new QLabel(tr("Heure :"          )));
	layout.addWidget(new QLabel(tr("Température (°) :")));
	layout.addWidget(new QLabel(tr("Humidité (%) :"   )));
	layout.addWidget(new QLabel(tr("Luminosité (%) :" )));
	setLayout(layoutUptr.release());
}

À ta décharge, bizarrement, la documentation de Qt 5 pour la classe QHBoxLayout donne un exemple dans lequel la mémoire est gérée comme dans ton code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    QWidget *window = new QWidget;
    QPushButton *button1 = new QPushButton("One");
    QPushButton *button2 = new QPushButton("Two");
    QPushButton *button3 = new QPushButton("Three");
    QPushButton *button4 = new QPushButton("Four");
    QPushButton *button5 = new QPushButton("Five");
 
    QHBoxLayout *layout = new QHBoxLayout;
    layout->addWidget(button1);
    layout->addWidget(button2);
    layout->addWidget(button3);
    layout->addWidget(button4);
    layout->addWidget(button5);
 
    window->setLayout(layout);
    window->show();

[koala01]

Héhéhé ... non...

Quand on utilise Qt, new est noexcept pour permettre au système parent / enfants de prendre correctement le relais

En plus, l'idée est de faire appel à chacun des widgets lors de la sauvegarde, vu que l'on a besoin de leur élément text().

Or, si tu le fait sous la forme que tu propose, au mieux, tu pourra accéder au contenu du layout sous une forme proche delayout()->itemAt(index)->widget();, qui te permettra d'avoir un élément de type... QWidget, que tu devras encore transtyper en un QLabel ou en un QSpinBox selon les besoins.

C'est faisable, mais c'est se faire du mal pour pas grand chose

Alors, je pourrais envisager plein d'autre solution pour la sauvegarde, comme par exemple le fait d'avoir un [cQList<std::string>[/c] dans ma classe TimeSlot que je mettrais d'une part à jour grâce à un QSignalMapper branché sur le signal valueChanged des QSpinBox et que j'utiliserais d'autre part dans la fonction save de mon TimeSlot.


Mais j'aurais quand même toujours besoin du pointeur sur les QSpinBox que je crée pour pouvoir faire la connexion avec le QSignalMapper et je n'aurais pas plus facile pour la cause

Ensuite, je pourrais récupérer cette liste de chaines de caractères pour tous les TimeSlots que je crée dans ma classe Planning et l'utiliser pour la sauvegarde, et, surtout, j'aurais un problème de synchronisation à résoudre entre les liste des TimeSlots et la liste du Planning, ce qui nécessiterait encore le recours à d'autres QSignalMapper.

Bref, encore une fois, ce serait se faire du mal pour rien

Tu le sais, je suis particulièrement attentif au problèmes liés à l'allocation dynamique de la mémoire, et de la distinction entre le propriétaire et l'utilisateur de ces ressources. Mais je suis aussi un fervent défenseur de la solution la plus simple

[Pyramidev]

Quand on utilise Qt, new est noexcept pour permettre au système parent / enfants de prendre correctement le relais

?????

Aurais-tu une source ? Je ne trouve rien à ce sujet.

De toute façon, le seul moyen de garantir qu'une telle tentative d'allocation de la mémoire ne lance pas d'exception serait de faire crasher le programme en cas de manque de mémoire. Ce serait étrange que Qt ait fait un tel choix.

D'ailleurs, pour gérer correctement la mémoire, un système parent / enfants n'a pas besoin que la tentative d'allocation de la mémoire ne lance pas d'exception.
La destruction du parent entraîne celle des enfants. Mais, si un enfant se détruit avant le parent, il le signale pour éviter d'être détruit une deuxième fois (par le parent).

Or, si tu le fait sous la forme que tu propose, au mieux, tu pourra accéder au contenu du layout sous une forme proche delayout()->itemAt(index)->widget();, qui te permettra d'avoir un élément de type... QWidget, que tu devras encore transtyper en un QLabel ou en un QSpinBox selon les besoins.

À la place de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
TimeSlot::TimeSlot(int hour, QWidget *parent) : QWidget(parent)
{
    time = new QLabel(QString::number(hour));
    temperature = new QSpinBox;
    humidity = new QSpinBox;
    luminosity = new QSpinBox;
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(time);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}

j'aurais écrit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
TimeSlot::TimeSlot(int hour, QWidget* parent) : QWidget(parent)
{
	auto timeUptr        = std::make_unique<QLabel>(QString::number(hour));
	auto temperatureUptr = std::make_unique<QSpinBox>();
	auto humidityUptr    = std::make_unique<QSpinBox>();
	auto luminosityUptr  = std::make_unique<QSpinBox>();
 
	m_notNullTime        = timeUptr       .get();
	m_notNullTemperature = temperatureUptr.get();
	m_notNullHumidity    = humidityUptr   .get();
	m_notNullLuminosity  = luminosityUptr .get();
 
	auto layoutUptr = std::make_unique<QHBoxLayout>();
	auto& layout = *layoutUptr;
	layout.addWidget(timeUptr       .release());
	layout.addWidget(temperatureUptr.release());
	layout.addWidget(humidityUptr   .release());
	layout.addWidget(luminosityUptr .release());
	setLayout(layoutUptr.release());
}

Il n'y a donc pas besoin de faire du downcasting.

Edit 2018-05-30-19h48 : Erreur de compilation corrigée : remplacement de setLayout(layout.release()); par setLayout(layoutUptr.release());.

[abii93200]

Salut Koala01

Ton code est super très clair et ca va je comprend à peu près tous le code. Maintenant je souhaiterais envoyer les données lors de l'appui du bouton enregistrer à une BDD qui est sur un serveur web.
J'ai préparé mon sender pour envoyer mes configurations journalières mais je n'arrive pas à récuperer les config.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
void Sender::Datagram()
{
    status->setText(tr("En train de diffuser datagram %1").arg(messageNo));
    QByteArray datagram = "Trames =" + QByteArray::number(messageNo);
    udpSocket->writeDatagram(datagram, QHostAddress::Broadcast, 45454);
 
    ++messageNo;
}

Merci beaucoup!!!

Salut Pyramidev

Merci de ta réponse aussi mais il me faut un code que je puisse expliquer lors de ma soutenance en fin d'année meme si ton code doit etre plus optimisé je souhaite juste seulement quelque chose qui marche pour commencer ^^


Merci à toi quand meme

[koala01]

@Pyramidev j'ai eu une discussion il y a quelques mois sur un forum dans laquelle je m'intéressais justement au problème de l'allocation dynamique...

Je serais bien en peine de retrouver cette discussion, et ce n'est d'ailleurs pas noexcept . Mais la conclusion de mon interlocuteur était -- en gros -- que l'on n'a aucun besoin de s'inquiéter des éventuels risques liés parce que c'était pris en charge par Qt.

Pourtant, j'avais moi aussi poussé la logique très loin, avec des oui mes et des si


@abii93200 Oui, mais, je ne vais pas faire tout le boulot pour toi, non plus.... Moi, j'ai déjà passé ma soutenance

Je t'ai donné un code qui démontre avec quelle facilité il est possible de créer des widgets personnalisés et des les utiliser. C'est maintenant à toi de l'adapter à tes besoins

Au pire, tu peux toujours fournir une ou des fonction(s) (dans TimeSlot) qui renvoi(ent) les valeurs des différents spinboxes, en faisant en sorte d'être en mesure d'y accéder depuis planning ou config.

Et, à partir de là, tu peux modifier le comportement de la fonction save pour qu'elle émette la requête adéquate vers la base de données

De même, tu peux tout à fait envisager de rajouter un bouton "Charger" dont le clique serait connecté à une fonction "load" et qui s'occuperait d'effectuer une requête auprès de ta base de donnée lui permettant de ... charger les informations qu'elles contient.

L'exemple que je t'ai donné est sous licence MIT. C'est à dire que tu peux en faire strictement ce que tu veux. Y compris modifier les paramètres / retours de fonctions / comportement si les comportements que j'ai mis en place pour l'exemple ne te conviennent pas

[Pyramidev]

La mémoire des composants graphiques de Qt est gérée à partir du moment où on spécifie l'objet parent.
Quand on appelle le constructeur de QObject avec, en paramètre, un objet parent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QObject::QObject(QObject *parent = nullptr)

l'objet parent devient le propriétaire de l'objet courant : parent->~QObject supprimera l'objet courant, sauf si celui-ci a déjà été détruit.

Par contre, si on crée un objet sans parent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QLabel * hour = new QLabel(tr("Heure :"));

alors, tant qu'aucun parent n'a été explicitement désigné, aucun mécanisme ne supprimera le QLabel pointé par hour avant la fin du programme. À ma connaissance, Qt n'a pas de ramasse-miettes.

C'est à partir de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

layout->addWidget(hour);

que le QLabel pointé par hour aura un objet parent : le QHBoxLayout pointé par layout.

[abii93200]

@koala01 "Au pire, tu peux toujours fournir une ou des fonction(s) (dans TimeSlot) qui renvoi(ent) les valeurs des différents spinboxes, en faisant en sorte d'être en mesure d'y accéder depuis planning ou config."

Mais je ne vois pas comment récuperer les différentes valeurs des spinbox afin de les envoyer dans mon sender. :/ je suis vraiment une merde en prog et la je dois rendre mon projet demain il me reste plus que ca à finir ...
Help please !

[koala01]

Ah, ben, sur ce coup là, je ne peux absolument rien pour toi:


J'aurais peut-êre pu t'aider

• si tu n'avais pas attendu le dernier jour pour faire ton travail de soutenance
• si tu n'avais pas attendu le dernier jour pour venir chercher de l'aide
• si tu n'avais pas attendu le dernier jour pour ouvrir tes livres et tes cours

Mais, là, comme tu sembles avoir glandé toute l'année, tu n'as que les résultats que tu mérites

[abii93200]

D'accord merci de ton aide déjà c'est cool de ta part, mais pour ton information je n'ai pas choisi le dernier jour pour faire cela je n'ai juste pas eu le choix.

[koala01]

D'accord merci de ton aide déjà c'est cool de ta part, mais pour ton information je n'ai pas choisi le dernier jour pour faire cela je n'ai juste pas eu le choix.

Hummm... j'ai un doute la dessus...

Depuis que tu as ce projet, oserais tu prétendre que tu n'aurais jamais pu trouver une demi-heure ou une heure par-ci par là pendant laquelle, au lieu de sortir avec tes potes ou de glander devant internet ou devant la TV, tu aurais pu (du) te dire "ben tiens, j'ai un peu de temps, je vais essayer d'avancer sur mon projet"

Le développement informatique n'est pas un domaine dans lequel il faut impérativement prévoir de longues périodes de travail "par défaut". Au contraire, c'est un domaine dans lequel il est primordial de s'accorder des pauses très régulières (au maximum toutes les heures ou toutes les deux heures), car, autrement, la productivité chute de manière spectaculaire.

Si bien que l'on ne prend la décision de "bosser au finish" que quand on n'a absolument plus le choix. Et, même dans cette optique, des pauses régulières pour "sortir le nez de la merde" sont nécessaires.

Si tu avais décidé d'accorder ne serait-ce que dix fois une demi heure à la prise en main de Qt et à peu près autant à l'assimilation du langage, en cinq à dix heures tu aurais pu sortir ton projet complet. Et tu n'aurais même pas eu besoin de bosser ces cinq à dix heures d'affilée, tu aurais pu le faire en dix ou en vingt fois une demi heure.

Tu avais sans doute de très bonnes raisons pour ne pas le faire, mais voilà...

De mon point de vue, le difficile est parti, l'impossible est en cours, mais pour le miracle, j'ai besoin d'un délais

[abii93200]

Bonjour à tous

Bon la soutenance est passée je verrai bien la note ^^ j'ai pas réussi à finir l'application elle est pas trop mal visuellement mais il me manque toute la partie de gestion de la plage horaire au travers de l'IHM. J'aimerais la finir pour m'améliorer en prog mais je n'arrive pas à faire en sorte que que quand une config est séléctionner par l'utilisateur sur la page de base, celle ci soit prise en compte et suivent la plage horaire définie. J'ai pensé mettre un QTimer (réglé sur l'heure courante) et qu'a chaque heure que le mode auto est activé, une fonction est appelé et recup les valeurs du de la config horaire active. Mais le problème c'est que je ne sais pas comment récuperer les valeurs de la configuration active...
Je vous met mon code d'IHM:
columm.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#ifndef COLUMNHEADER_H
#define COLUMNHEADER_H
 
#include <QWidget>
 
class ColumnHeader : public QWidget
{
    Q_OBJECT
public:
    explicit ColumnHeader(QWidget *parent = nullptr);
 
signals:
 
public slots:
};
 
#endif // COLUMNHEADER_H

columm.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "columnheader.h"
#include <QLabel>
#include <QHBoxLayout>
ColumnHeader::ColumnHeader(QWidget *parent) : QWidget(parent)
{
    QLabel * hour = new QLabel(tr("Heure :"));
    QLabel * temperature = new QLabel(tr("Température °"));
    QLabel * humidity = new QLabel(tr("Humidité %"));
    QLabel * luminosity = new QLabel(tr("Luminosité %"));
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(hour);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}

config.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#ifndef CONFIG_H
#define CONFIG_H
 
#include <QWidget>
#include <string>
class Planning;
class QPushButton;
class Config : public QWidget
{
    Q_OBJECT
public:
    explicit Config(int configNumber);
 
signals:
 
public slots:
    void save();
    void charger();
private:
    std::string filename;
    Planning * am;
    Planning * pm;
    QPushButton * saveButton;
    QPushButton * Charger;
};
 
#endif // CONFIG_H

config.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "config.h"
#include "planning.h"
#include <fstream>
#include <QPushButton>
#include <QHBoxLayout>
Config::Config(int configNumber) : filename("config")
{
    filename.append(std::to_string(configNumber))
            .append(".txt");
    am = new Planning(AM);
    pm = new Planning(PM);
    saveButton = new QPushButton(tr("Enregistrer"));
    Charger = new QPushButton(tr("Charger"));
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(am);
    layout->addWidget(pm);
    layout->addWidget(saveButton);
    layout->addWidget(Charger);
    setLayout(layout);
    connect(saveButton, &QPushButton::clicked, this, &Config::save);
    connect(Charger, &QPushButton::clicked,this, &Config::charger);
 
}
void Config::save(){
    std::ofstream ofs(filename);
    am->save(ofs);
    pm->save(ofs);
}
void Config::charger()
{
 
}

mainWindow.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
class Planning;
class QPushButton;
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
 
 
private:
    QPushButton * exit;
};
 
#endif // MAINWINDOW_H

mainWindow.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "mainwindow.h"
#include "planning.h"
#include <QPushButton>
#include <QTabWidget>
#include "config.h"
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    QTabWidget * widget = new QTabWidget;
    widget->addTab(new Config(1),tr("Configuration 1"));
    widget->addTab(new Config(2),tr("Configuration 2"));
    widget->addTab(new Config(3),tr("Configuration 3"));
    widget->addTab(new Config(4),tr("Configuration 4"));
    widget->addTab(new Config(5),tr("Configuration 5"));
    widget->addTab(new Config(6),tr("Configuration 6"));
    widget->addTab(new Config(7),tr("Configuration 7"));
    widget->addTab(new Config(8),tr("Configuration 8"));
    setCentralWidget(widget);
}

page_principale.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#ifndef DEF_MAFENETRE
#define DEF_MAFENETRE
 
#include <QtWidgets>
#include "mainwindow.h"
 
 
class MaFenetre : public QMainWindow
{
    Q_OBJECT
 
    public:
    MaFenetre();
 
    private:
 
    MainWindow *plage;
 
    QLabel *temperaturelabel;
    QHBoxLayout *Temperature;
    QHBoxLayout *Tempe;
    QVBoxLayout *temp;
    QGroupBox *groupetemperature;
    QPushButton *plustemp;
    QPushButton *moinstemp;
    QLCDNumber *affichagetemperature;
    QLCDNumber *affichagetemperaturesouhaite;
 
    QLabel *humiditelabel;
    QHBoxLayout *humidite;
    QVBoxLayout *humidi;
    QVBoxLayout *humi;
    QGroupBox *groupehumidite;
    QSlider *reglagehumidite;
    QProgressBar *affichagehumiditesouhaite;
    QProgressBar *affichagehumidite;
 
    QLabel *luminositelabel;
    QHBoxLayout *luminosi;
    QVBoxLayout *luminosite;
    QGroupBox *groupeluminosite;
    QSlider *reglageluminosite;
    QProgressBar *affichageluminositesouhaite;
    QProgressBar *affichageluminosite;
 
    QHBoxLayout *mode;
    QGroupBox *groupemode;
    QHBoxLayout *configuration;
    QGroupBox *groupeconfiguration;
    QCheckBox *jours;
    QCheckBox *semaine;
    QSpinBox *numconfig;
    QCheckBox *automatique;
 
 
 
 
    QHBoxLayout *layoutconfig;
 
    QHBoxLayout *layoutprincipalemesure;
    QVBoxLayout *layoutprincipale;
    short c=1;
    short t=0;
    short nbrtemp=0;
    short nbrhygro=0;
 
 
 
private slots:
    void afficher_reglage_plagesemaine();
    void afficher_reglage_plagejournee();
    void plustemperature();
    void moinstemperature();
    void modeauto(int valeur);
    void selectionjournee(int valeur);
    void envoyertemperature();
 
 
 
 
 
  };
#endif

pageprincipale.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#include "page_principale.h"
 
 
 
MaFenetre::MaFenetre() : QMainWindow()
{
    QWidget *zoneCentrale = new QWidget;
    setWindowTitle("E-GARDEN");
    setWindowIcon(QIcon("icon.png"));
 
    QMenu *menuGestion = menuBar()->addMenu("&Gestion");
 
 
    QAction *actionQuitter = new QAction("&Quitter", this);
    menuGestion->addAction(actionQuitter);
    actionQuitter->setShortcut(QKeySequence("Ctrl+Q"));
    actionQuitter->setIcon(QIcon("quitter.png"));
 
    QAction *actionGestionplagejournee = new QAction("&Gestion plages journée",this);
    menuGestion->addAction(actionGestionplagejournee);
    actionGestionplagejournee->setShortcut(QKeySequence("Ctlr+A"));
    actionGestionplagejournee->setIcon(QIcon("icone-reglage.png"));
 
    QAction *actionGestionplagesemaine = new QAction("&Gestion plages semaines",this);
    actionGestionplagesemaine->setIcon(QIcon("week.jpg"));
    QMenu *menuEdition = menuBar()->addMenu("&Edition");
    QMenu *menuAffichage = menuBar()->addMenu("&Affichage");
    menuGestion->addAction(actionGestionplagesemaine);
    QToolBar *toolBarFichier = addToolBar("Fichier");
    toolBarFichier->addAction(actionQuitter);
    toolBarFichier->addAction(actionGestionplagejournee);
    toolBarFichier->addAction(actionGestionplagesemaine);
 
    plustemp = new QPushButton("+",this);
    plustemp->setCursor(Qt::PointingHandCursor);
    plustemp->setFont(QFont("Comic Sans MS",22,QFont::Bold));
    moinstemp = new QPushButton("-",this);
    moinstemp->setCursor(Qt::PointingHandCursor);
    moinstemp->setFont(QFont("Comic Sans MS",22,QFont::Bold));
    affichagetemperature = new QLCDNumber(this);
    affichagetemperaturesouhaite = new QLCDNumber(this);
    temperaturelabel = new QLabel("Température actuelle :");
         Temperature = new QHBoxLayout;
         Temperature->addWidget(temperaturelabel);
         Temperature->addWidget(affichagetemperaturesouhaite);
         Tempe = new QHBoxLayout;
         Tempe->addWidget(affichagetemperature);
         Tempe->addWidget(plustemp);
         Tempe->addWidget(moinstemp);
         temp= new QVBoxLayout;
         temp->addLayout(Temperature);
         temp->addLayout(Tempe);
         groupetemperature = new QGroupBox;
         groupetemperature->setLayout(temp);
 
 
 
 
         reglagehumidite = new QSlider(Qt::Horizontal,this);
         reglagehumidite->setRange(0,100);
         affichagehumidite = new QProgressBar;
         affichagehumiditesouhaite= new QProgressBar;
         humiditelabel = new QLabel("Humidité actuelle :");
 
             humidite=new QHBoxLayout;
             humidite->addWidget(humiditelabel);
             humidite->addWidget(affichagehumiditesouhaite);
             humidi= new QVBoxLayout;
             humidi->addWidget(affichagehumidite);
             humidi->addWidget(reglagehumidite);
             humi= new QVBoxLayout;
             humi->addLayout(humidite);
             humi->addLayout(humidi);
             groupehumidite=new QGroupBox;
             groupehumidite->setLayout(humi);
 
 
 
    luminositelabel=new QLabel("Luminosité actuelle :");
    affichageluminositesouhaite= new QProgressBar;
    reglageluminosite=new QSlider(Qt::Horizontal,this);
    reglageluminosite->setRange(0,100);
    affichageluminosite = new QProgressBar;
 
        luminosi = new QHBoxLayout;
        luminosi->addWidget(luminositelabel);
        luminosi->addWidget(affichageluminositesouhaite);
        luminosite= new QVBoxLayout;
        luminosite->addLayout(luminosi);
        luminosite->addWidget(affichageluminosite);
        luminosite->addWidget(reglageluminosite);
        groupeluminosite= new QGroupBox;
        groupeluminosite -> setLayout(luminosite);
 
    automatique = new QCheckBox("Automatique",this);
 
    numconfig = new QSpinBox;
    jours = new QCheckBox("Jours",this);
    semaine = new QCheckBox("Année",this);
    mode = new QHBoxLayout;
    mode->addWidget(automatique);
    groupemode= new QGroupBox("Mode :");
    groupemode->setLayout(mode);
    configuration = new QHBoxLayout;
    configuration->addWidget(jours);
    configuration->addWidget(semaine);
    configuration->addWidget(numconfig);
    groupeconfiguration = new QGroupBox("Configuration :");
    groupeconfiguration->setLayout(configuration);
    groupeconfiguration->setEnabled(false);
 
 
 
 
 
        layoutconfig = new QHBoxLayout;
        layoutconfig->addWidget(groupemode);
        layoutconfig->addWidget(groupeconfiguration);
 
 
        layoutprincipalemesure = new QHBoxLayout;
        layoutprincipalemesure->addWidget(groupetemperature);
        layoutprincipalemesure->addWidget(groupehumidite);
         layoutprincipalemesure->addWidget(groupeluminosite);
 
         layoutprincipale = new QVBoxLayout;
         layoutprincipale->addLayout(layoutprincipalemesure);
         layoutprincipale->addLayout(layoutconfig);
 
         zoneCentrale->setLayout(layoutprincipale);
         setCentralWidget(zoneCentrale);
 
   QObject::connect(automatique, SIGNAL(stateChanged(int)), this, SLOT(modeauto(int)));
   QObject::connect(reglageluminosite, SIGNAL(valueChanged(int)), affichageluminosite, SLOT(setValue(int)));
   QObject::connect(reglagehumidite, SIGNAL(valueChanged(int)), affichagehumidite, SLOT(setValue(int)));
   connect(actionQuitter, SIGNAL(triggered()), qApp, SLOT(quit()));
   connect(actionGestionplagejournee,SIGNAL(triggered()),this,SLOT(afficher_reglage_plagejournee()));
   connect(actionGestionplagesemaine,SIGNAL(triggered()),this,SLOT(afficher_reglage_plagesemaine()));
   QObject::connect(plustemp,SIGNAL(clicked()),this,SLOT(envoyertemperature()));
   QObject::connect(jours,SIGNAL(stateChanged(int)),this,SLOT(selectionjournee(int)));
 
   QObject::connect(plustemp,SIGNAL(clicked()),this,SLOT(plustemperature()));
 
   QObject::connect(moinstemp,SIGNAL(clicked()),this,SLOT(moinstemperature()));
 
}
void MaFenetre::selectionjournee(int valeur)
{
 
}
 
void MaFenetre::modeauto(int valeur)
{
    if (valeur==0) groupeconfiguration->setEnabled(false);
     else groupeconfiguration->setEnabled(true);
}
 
 
void MaFenetre::afficher_reglage_plagejournee()
{
    plage = new MainWindow();
    plage->show();
}
void MaFenetre::afficher_reglage_plagesemaine()
{
    /*plage = new MainWindow();
    plage->show();*/
}
 
void MaFenetre::plustemperature()
{
    nbrtemp=nbrtemp+c;
    affichagetemperature->display(QString::number(nbrtemp));
}
 
void MaFenetre::moinstemperature()
{
    nbrtemp=nbrtemp-c;
    affichagetemperature->display(QString::number(nbrtemp));
}
void MaFenetre::envoyertemperature()
{
 
   // affichagetemperature->
 
}

planning.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifndef PLANNING_H
#define PLANNING_H
 
#include <QWidget>
#include <QList>
class TimeSlot;
enum DayPart{
    AM = 0,
    PM = 12
};
class Planning : public QWidget
{
    Q_OBJECT
  public:
    Planning(DayPart part);
      /* parce que l'on veut pouvoir sauvegarder le planning entier */
      void save(std::ofstream& ofs);
  private:
      /* parce que pour sauvegarder le planning, il faut pouvoir accéder à
       * toutes les plages horraires
       */
      QList<TimeSlot * > allSlots;
};
 
#endif // PLANNING_H

planning.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include "planning.h"
#include "columnheader.h"
#include "timeslot.h"
#include <QVBoxLayout>
Planning::Planning(DayPart part)
{
 
    QVBoxLayout * layout = new QVBoxLayout;
    /* d'abord, les en-têtes */
    ColumnHeader * headers = new ColumnHeader;
    layout->addWidget(headers);
    /* ensuite, les 24 plages horaires */
    for(int i = part+ 0; i<part+12; ++i){
        TimeSlot * temp = new TimeSlot(i);
         layout->addWidget(temp);
         allSlots.append(temp);
    }
    setLayout(layout);
}
 
void Planning::save(std::ofstream & ofs)
{
    for(auto * it : allSlots)
        it->save(ofs);
}

timeslot.h

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef TIMESLOT_H
#define TIMESLOT_H
 
#include <QWidget>
#include <fstream>
class  QSpinBox;
class QLabel;
class TimeSlot : public QWidget
{
    Q_OBJECT
public:
    explicit TimeSlot(int hour, QWidget *parent = nullptr);
    void save(std::ofstream& ofs);
    void envoie_conf(std::ofstream& obs);
    private:
        QLabel * time;
        QSpinBox * temperature;
        QSpinBox * humidity;
        QSpinBox * luminosity;
};
 
#endif // TIMESLOT_H

timeslot.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include "timeslot.h"
 
#include <QSpinBox>
#include <QLabel>
#include <QHBoxLayout>
TimeSlot::TimeSlot(int hour, QWidget *parent) : QWidget(parent)
{
    time = new QLabel(QString::number(hour));
    temperature = new QSpinBox;
    humidity = new QSpinBox;
    luminosity = new QSpinBox;
    QHBoxLayout * layout = new QHBoxLayout;
    layout->addWidget(time);
    layout->addWidget(temperature);
    layout->addWidget(humidity);
    layout->addWidget(luminosity);
    setLayout(layout);
}
void TimeSlot::save(std::ofstream & ofs){
    ofs<<time->text().toStdString()<<";"
      <<temperature->text().toStdString()<<";"
      <<humidity->text().toStdString()<<";"
      <<luminosity->text().toStdString()<<";\n";
 
}
 
void TimeSlot::envoie_conf(std::ofstream &obs){
    obs<<time->text().toStdString()<<";"
      <<temperature->text().toStdString()<<";"
      <<humidity->text().toStdString()<<";"
      <<luminosity->text().toStdString()<<";";
}