signals not work

Hi, I'm trying to create a signal, but I can't see the code. I'm trying to prevent reading and writing to a file at the same time with QSetting. Is there perhaps another way? Thanks.

mainwindow.h

Code:

---

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QtWidgets>
 
#include "parametres.h"
#include "threadsondes.h"
#include "gainable.h"
#include "affichecons.h"
 
class MainWindow: public QWidget
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = nullptr);
 
signals:
    void lectureEnCours(bool m_lecture);

---

mainwindow.cpp

Code:

---

#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    :QWidget (parent)
{
connect(this, &MainWindow::lectureEnCours, &m_mainwindowThreadSondes, &ThreadSondes::onLitEnCours);
 
    m_timer1 = new QTimer(this);
    m_timer1 ->start(m_timerTemps);
    connect(m_timer1, &QTimer::timeout, this, &MainWindow::lectureTemperatures);
}
 
void MainWindow::lectureTemperatures()
{
    qDebug() << "lectureTemperature() MainWindow";
 
    emit lectureEnCours(true);
}

---

threadsondes.h

Code:

---

#ifndef THREADSONDES_H
#define THREADSONDES_H
 
#include <QThread>
 
#include <QObject>
 
#include "sondes.h"
 
class ThreadSondes: public QThread
{
	Q_OBJECT
 
public:
    ThreadSondes();
 
    bool lecture = false;
 
    void lectureTemperaturesEnCours();
 
public slots:
    void onLitEnCours(bool m_lecture);
 
signals:
 
private:
    DS18b20 m_threadSondesDS18b20;
 
    void run();
 
};
 
threadsondes.cpp
 
[CODE]
#include "threadsondes.h"
 
#include <QDebug>
 
ThreadSondes::ThreadSondes()
{
    qDebug() << "ThreadSondes";
}
 
void ThreadSondes::onLitEnCours(bool m_lecture)
{
    lecture = m_lecture;
}
 
void ThreadSondes::lectureTemperaturesEnCours()
{
    if (lecture == true) {
	qDebug() << "lecture = " << lecture;
    } else {
	qDebug() << "lecture = " << lecture;
    }
}
 
void ThreadSondes::run()
{
    while (1) {
 
	qDebug() << "run ThreadSondes()";
 
	lectureTemperaturesEnCours();
 
	/*m_threadSondesDS18b20.lectureSondeExt(); // on ecrite dans parametres en meme temps
	m_threadSondesDS18b20.lectureSondeUnitExt();
	m_threadSondesDS18b20.lectureSondeEcExt();
	m_threadSondesDS18b20.lectureSondeUnitInt();
	m_threadSondesDS18b20.lectureSondeEcInt();
 
	sleep(5);*/
    }
}

---

[/CODE]

Quote:

---

I'm trying to prevent reading and writing to a file at the same time with QSetting. Is there perhaps another way?

---

You should use a QMutex for this.

Code:

---

class SomeQtWidget : public QWidget
{
    Q_OBJECT;
 
public:
 
// ...
 
void  WriteSettings()
{
    mutex.lock();
 
    // write QSettings
 
   mutex.unlock();
}
 
void ReadSettings()
{
   mutex.lock()
 
   // read QSettings
 
   mutex.unlock();
}
 
private:
   QMutex  mutex;
 
};

---

Also in your Thread class, the run() method is an infinite loop that never gives the Qt event loop the opportunity to execute. So it will completely block any signals or slots in the thread from executing. As I explained in earlier posts, you need to call the processEvents() method in your thread classes.

Hi, I'm starting from scratch with a thread without run();
I can't get my signal to work anymore; it's always true!

And if you have any ideas for organizing my code, see my other posts.

Code:

---

#include "mainwindow.h"
 
#include <QApplication>
#include <QDebug>
 
#include "consignes.h"
#include "threadsondes.h"
 
Consignes *m_initConsignes;
ThreadSondes m_mainThreadSondes;
 
int main(int argc, char *argv[])
{
    qDebug() << "main";
 
    QApplication app(argc, argv);
    QApplication::setOverrideCursor(QCursor(Qt::BlankCursor)); // cache pointeur Sourie
 
    m_initConsignes = new Consignes(QString("settings/consignes.ini"), QSettings::IniFormat);
    m_initConsignes ->controleConsignes();
 
    QThread* m_thread = new QThread();
    m_mainThreadSondes.moveToThread(m_thread);
    QObject::connect(m_thread, &QThread::started, &m_mainThreadSondes, &ThreadSondes::process);
    m_thread ->start();
 
    MainWindow window;
 
    return app.exec();
}

---

Code:

---

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QtWidgets>
 
#include "temperatures.h"
#include "threadsondes.h"
#include "affichecons.h"
 
class MainWindow: public QWidget
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = nullptr);
 
    QTimer *m_timer1;
 
    int m_timerTemps = 10000;
 
public slots:
    void changeLabel(int m_mode);
 
signals:    
    void changeGainableState(bool m_state);
 
private:
    Temperatures *m_mainwindowTemperatures;
 
    ThreadSondes m_mainwindowThreadSondes;
 
    AfficheCons *m_afficheCons;
 
    QWidget *m_window;
 
    QLabel *m_label;
 
    QLCDNumber *m_tempExtLue;
    QLCDNumber *m_tempUnitExtLue;
    QLCDNumber *m_tempEcExtLue;
    QLCDNumber *m_tempUnitIntLue;
    QLCDNumber *m_tempEcIntLue;
 
    QGroupBox *m_disp1; //tempExt
    QGroupBox *m_disp2; //tempUnitExt
    QGroupBox *m_disp3; //tempEcExt
    QGroupBox *m_disp4; //tempUnitInt
    QGroupBox *m_disp5; //tempEcInt
 
    QPushButton *m_marche;
    QPushButton *m_consigne;
    QPushButton *m_stop;
 
    void affichageTemperatures();
 
    void afficheConsignes();
    void stopGainable();
    void reStartGainable();
};
#endif // MAINWINDOW_H

---

Code:

---

#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    :QWidget (parent)
{
    qDebug() << "Mainwindow";
 
    m_mainwindowTemperatures = new Temperatures(QString("settings/temperatures.ini"), QSettings::IniFormat);
 
    m_window = new QWidget;
    m_window ->setFixedSize(1920,1080);
    m_window ->setWindowTitle("Gainable");
    adjustSize();
 
    m_label = new QLabel(m_window);
 
    m_disp1 = new QGroupBox("Temp°C Ext",m_window);
    m_disp1 ->setStyleSheet("QGroupBox:title {color: orangered;}");
    m_disp1 ->setFont(QFont("Times", 18, QFont::Bold));
    m_disp1 ->setGeometry(200,40,240,120);
    m_tempExtLue = new QLCDNumber(m_disp1);
    m_tempExtLue ->setGeometry(0,35,240,80);
 
    m_disp2 = new QGroupBox("Temp°C UnitExt",m_window);
    m_disp2 ->setStyleSheet("QGroupBox:title {color: orangered;}");
    m_disp2 ->setFont(QFont("Times", 18, QFont::Bold));
    m_disp2 ->setGeometry(520,40,240,120);
    m_tempUnitExtLue = new QLCDNumber(m_disp2);
    m_tempUnitExtLue ->setGeometry(0,35,240,80);
 
    m_disp3 = new QGroupBox("Temp°C EcUnitExt",m_window);
    m_disp3 ->setStyleSheet("QGroupBox:title {color: orangered;}");
    m_disp3 ->setFont(QFont("Times", 18, QFont::Bold));
    m_disp3 ->setGeometry(840,40,240,120);
    m_tempEcExtLue = new QLCDNumber(m_disp3);
    m_tempEcExtLue ->setGeometry(0,35,240,80);
 
    m_disp4 = new QGroupBox("Temp°C UnitInt",m_window);
    m_disp4 ->setStyleSheet("QGroupBox:title {color: orangered;}");
    m_disp4 ->setFont(QFont("Times", 18, QFont::Bold));
    m_disp4 ->setGeometry(1160,40,240,120);
    m_tempUnitIntLue = new QLCDNumber(m_disp4);
    m_tempUnitIntLue ->setGeometry(0,35,240,80);
 
    m_disp5 = new QGroupBox("Temp°C EcUnitInt",m_window);
    m_disp5 ->setStyleSheet("QGroupBox:title {color: orangered;}");
    m_disp5 ->setFont(QFont("Times", 18, QFont::Bold));
    m_disp5 ->setGeometry(1480,40,240,120);
    m_tempEcIntLue = new QLCDNumber(m_disp5);
    m_tempEcIntLue ->setGeometry(0,35,240,80);
 
    affichageTemperatures();
 
    m_marche = new QPushButton("Démarrage ??",m_window);
    m_marche ->setGeometry(1080,900,240,95);
    m_marche ->setStyleSheet("font-size: 30px;background-color: lime");
    m_marche ->hide();
 
    m_consigne = new QPushButton("Consignes",m_window);
    m_consigne ->setGeometry(1340,900,240,95);
    m_consigne ->setStyleSheet("font-size: 30px;");
    m_consigne ->show();
 
    m_stop = new QPushButton("Stop ??",m_window);
    m_stop ->setGeometry(1600,900,240,95);
    m_stop ->setStyleSheet("font-size: 30px;background-color: red");
    m_stop ->show();
 
    m_timer1 = new QTimer(this);
    m_timer1 ->start(m_timerTemps);
    connect(m_timer1, &QTimer::timeout, this, &MainWindow::affichageTemperatures); // affiche temperature toute les 10 secondes
 
    changeLabel(3);
 
    connect(m_marche, &QPushButton::clicked, this, &MainWindow::reStartGainable);
    connect(m_consigne, &QPushButton::clicked, this, &MainWindow::afficheConsignes);
    connect(m_stop, &QPushButton::clicked, this, &MainWindow::stopGainable);
 
    connect(this, &MainWindow::changeGainableState, &m_mainwindowThreadSondes, &ThreadSondes::onChangeGainableState);
 
    m_window->show();
}
 
void MainWindow::affichageTemperatures()
{
    m_mainwindowTemperatures ->lireToutesTemperatures();
 
    m_tempExtLue ->display(m_mainwindowTemperatures ->temperatureExt);
    m_tempUnitExtLue ->display(m_mainwindowTemperatures ->temperatureUnitExt);
    m_tempEcExtLue ->display(m_mainwindowTemperatures ->temperatureEcExt);
    m_tempUnitIntLue ->display(m_mainwindowTemperatures ->temperatureUnitInt);
    m_tempEcIntLue ->display(m_mainwindowTemperatures ->temperatureEcInt);
}
 
void MainWindow::changeLabel(int m_mode)
{
    switch (m_mode) {
 
        case 0:
 
        m_label ->setPixmap(QPixmap("/home/ludo/Qt/test2/build/images/froid.jpg"));
 
        break;
 
        case 1:
 
        m_label ->setPixmap(QPixmap("/home/ludo/Qt/test2/build/images/chauffage.jpg"));
 
        break;
 
        case 2:
 
        m_label ->setPixmap(QPixmap("/home/ludo/Qt/test2/build/images/canicule.jpg"));
 
        break;
 
        default:
 
        m_label ->setPixmap(QPixmap("/home/ludo/Qt/test2/build/images/abigael.jpg"));
 
        break;
 
     }
}
 
void MainWindow::afficheConsignes()
{
    qDebug() << "afficheConsignes()";
    m_afficheCons = new AfficheCons();
    m_afficheCons ->readCons();
}
 
void MainWindow::stopGainable()
{
    qDebug() << "stopGainable()";
    m_stop ->hide();
    m_marche ->show();
    emit changeGainableState(false);
}
 
void MainWindow::reStartGainable()
{
    qDebug() << "restartGainable()";
    m_marche ->hide();
    m_stop ->show();
    emit changeGainableState(true);
}

---

Code:

---

#ifndef THREADSONDES_H
#define THREADSONDES_H
 
#include "temperatures.h"
 
class ThreadSondes: public QObject
{
	Q_OBJECT
 
public:
    ThreadSondes();
 
    ~ThreadSondes();
 
public slots:
    void process();
 
    void onChangeGainableState(bool m_state);
 
signals:
 
private:
    Temperatures *m_threadSondesTemperatures;
 
    bool departGainable = true;
 
    float tempoEcritureTemperatures = 15;
    unsigned long long departTempoEcritureTemperatures;
 
    void ecritToutesTemperaturesLue();
};
 
#endif //THREADSONDES

---

Code:

---

#include "threadsondes.h"
 
#include <QDebug>
 
#include <ctime>
 
ThreadSondes::ThreadSondes()
{
    qDebug() << "ThreadSondes";
 
    m_threadSondesTemperatures = new Temperatures(QString("settings/temperatures.ini"), QSettings::IniFormat);
}
 
ThreadSondes::~ThreadSondes()
{
 
}
 
void ThreadSondes::onChangeGainableState(bool m_state)
{
    departGainable = m_state;
}
 
void ThreadSondes::process()
{
    qDebug() << "process()";
 
    while(1) {
 
        qDebug() << departGainable;
 
        if (time(NULL) - departTempoEcritureTemperatures >= tempoEcritureTemperatures) {
            m_threadSondesTemperatures ->ecritToutesTemperatures();
            departTempoEcritureTemperatures = time(NULL);
        }
    }
 
}

---

Now you block the Qt queue in the process method (while(1) loop). Use Qtimer to run the process method periodically.