qextserialport write and progress bar

[JonB]

@another_one
I have no idea whether you have a CentOS issue with physically showing the progress bar. But you do realise that with your code you likely won't see any progress at all, you will simply see the bar at 100% complete at the end? The UI will not be updated during your for loop calling bar->setValue(i) because (so far as I know) port->write() doesn't yield for that, it won't be refreshed till after the bar->setValue(fls).

You can test the progress bar drawing with a simple QTimer() timing out, say, once per second and causing in increment; not your code with a for loop or port->write(). that would tell you whether the CentOS progress bar drawing is working.

[another_one]

@JonB
sorry, i forgot to say what this code on Ws works well
I just compile it in cent os and all is work except progress bar bag with black screen instead

[jsulm]

@another_one Your current code can't work. As long as the for loop calling bar->setValue(i) is running Qt event loop is blocked and the progress bar will not update or even be black or whatever.
You could call https://doc.qt.io/qt-6/qcoreapplication.html#processEvents inside same loop, but that is a ugly work around. Proper solution in this case would be to move the serial port handling into another thread and emit a signal from that thread every time you want to update the progress bar.

[another_one]

@jsulm
Thank you for your advice!
I already use serial port handling but only when I read:

   connect(port, SIGNAL(readyRead()), this, SLOT(readData()));

And here I use readyRead() emiting
In my byte by byte writing case, can I use bytesWritten(one byte) to increment, in thread, the progress bar ?

[JonB]

@another_one

to increment, in thread, the progress bar ?

If you use another thread to do the serial port stuff you must not directly update the progress bar, you must send a signal from the serial thread to the main UI thread, like @jsulm wrote.

[another_one]

@JonB
Thank you, now I undestand for what I should do it
But can't imagine the construction itself
Can anybody give me an example?, please

[JonB]

@another_one
What is there to say? Above you have code to connect() signal and slot, you need to do a connect here too. The https://doc.qt.io/qt-6/signalsandslots.html#a-small-example is enough to follow for your case.

[another_one]

@JonB

Thanks!
Ive done another thread but it got worse
First I set global variable of progress bar/ data iteration

unsigned long ii = 0;

After Ive done the link:

 connect(port, SIGNAL(bytesWritten(qint64)), this, SLOT(writeData(qint64)));
void monMK::writeData(qint64)
{
bar->setValue(ii);
 qDebug() << "ii progress bar value" << ii;
}
void mM::on_open_folder_clicked()
{// from button clicked
....
....
....

   bar = new QProgressDialog(this);

           port->write(dataArr4);
           bar->setLabelText(tr("loading..."));
           bar->setCancelButtonText(tr("&Cancel"));
          
           bar->setMinimumDuration(0); 
           bar->setWindowTitle(tr("Loading"));
           bar->setVisible(1);
           qApp->processEvents();
           bar->setValue(1);
           bar->setRange(1, fls-1); // where fls size of File stored
        
           for(ii=0;ii<fls;ii++)
           {
            y = arr.mid(ii, 1 );     /
            port->write(y,1);
            //port->waitForBytesWritten(1);
           }
....
}

As result I see progress bar appering and stopping on 0 %
While in debug i see:
"
ii progress bar value 0
// several time waiting
ii progress bar value 77457
"
So please help!

[jsulm]

@another_one What is the size of the file?
There is no need for any global variables, simply use the parameter of your slot:

void monMK::writeData(qint64 ii)
{
 bar->setValue(ii);
 qDebug() << "ii progress bar value" << ii;
}

You should stop using old connect syntax.
The actual issue is that you write the data in one blocking loop inside on_open_folder_clicked() - this blocks the Qt event loop.

[another_one]

@jsulm said in qextserialport write and progress bar:
What is the size of the file?*
Thank you for your replay!
The size of File is 77457 Bytes
How can I transfer ii value from "button clicked" to slot writeData?, via port->waitForBytesWritten(ii);?
You should stop using old connect syntax.
The actual issue is that you write the data in one blocking loop inside on_open_folder_clicked() - this blocks the Qt event loop.*
Sorry, here, again, I didnt undestand
How can I fdo write data(write the File) in non-blocking state?, Can you give me an example how its possible to do unblocked file writing to qextserialport?, please
Cause I didnt undestand how "Code of Conduct" can help in this case
Thanks in advance!

[jsulm]

@another_one Please take a look at this example application: https://doc.qt.io/qt-5/qtserialport-cwriterasync-example.html

[another_one]

@jsulm

Thank you for this example!
It' seems to be what I need, but I wanted to clarify about progress bar using in SerialPortWriter class, - can I increment progress bar in :handleBytesWritten ??

Thank you!

[SGaist]

@another_one emit a signal from that class and connect that one to the progress bar. That way you avoid leaking GUI knowledge in your business logic class.

[another_one]

@SGaist

Thank you!
I'm trying doing in this way but when I connect my signal the program exit and closed automatically :

My class:

class qextserpw : public QObject
{
    Q_OBJECT
public:
   // explicit qextserpw(QObject *parent = nullptr);
    explicit qextserpw(QextSerialPort  *serialPort, QObject *parent = nullptr);
        void write(const QByteArray &writeData);

//private slots:
 public slots:
        void handleBytesWritten(qint64 bytes);


private:
    QextSerialPort *m_serialPort = nullptr;
    QByteArray m_writeData;

    qint64 m_bytesWritten = 0;
signals:
    void inprogress(unsigned long progr);
};

#endif // QEXTSERPW_H

#include <QtDebug>
#include <QtGlobal>
#include <QtCore>
#include <QProgressDialog>

//qextserpw::qextserpw(QObject *parent) : QObject(parent)
  qextserpw::qextserpw(QextSerialPort *serialPort, QObject *parent)

{

}
  void qextserpw::handleBytesWritten(qint64 bytes)
  {


  }

And these connection gots failed launch of program
:

qextserpw *qextser;
    connect(qextser, SIGNAL(inprogress(int progr)), bar, SLOT(setValue(progr)));


// or

  connect(qextser, SIGNAL( inprogress(int) ), bar, SLOT( setValue(int) ) );

[Christian Ehrlicher]

@another_one said in qextserialport write and progress bar:

qextserpw *qextser;

Don't you think this variable should contain a valid pointer before it's used?

[another_one]

@Christian-Ehrlicher

Unfortunally it doesn't help

qextserpw  *qextser = new qextserpw(port);
connect(port, SIGNAL(bytesWritten(qint64)), this, SLOT(writeData(qint64)));
connect(qextser, SIGNAL( inprogress(int) ), bar, SLOT( setValue(int) ) );

[another_one]

@another_one

sorry, I forgot about bar initialization too
Now program can launch but I have got the same problem with progress bar...

[JonB]

@another_one What exact "same problem with progress bar..."?

[another_one]

@JonB
I can't parallelize read from qexteserialport, write to qextserialport and setValue to progress bar while writing
To do what I create qextserpw class:

qextserpw.h

#ifndef QEXTSERPW_H
#define QEXTSERPW_H

#include <QObject>
#include <QtCore/QIODevice>
#include <qextserialport.h>

#include <QDebug>
#include "terminal.h"


class qextserpw : public QObject
{
    Q_OBJECT
public:
    explicit qextserpw();
    void write(const QByteArray &writeData);
    QextSerialPort *port = new QextSerialPort (QextSerialPort::EventDriven);
    bool m_open(QIODevice::OpenMode mode);
    void m_port_close();
    bool check_open();
    bool status_port;
public slots:
    //void handleBytesWritten(qint64 bytes);
	void m_readAll();
private:
    QextSerialPort *m_serialPort = nullptr;
    //QByteArray m_writeData;
    //qint64 m_bytesWritten = 0;
signals:
    void inprogress(QByteArray data);
    //void to_store();
    void towrite();
};

#endif // QEXTSERPW_H

qextserpw.c

#include "qextserpw.h"
#include "monmk.h"
#include "terminal.h"
#include <QDebug>
#include <QtGlobal>
#include <QtCore>
#include <QProgressDialog>
#include <QtCore/QIODevice>

 qextserpw::qextserpw()
{
    port = new QextSerialPort (QextSerialPort::EventDriven); // настройка работы порта в асинхронном режиме чтения и записи
    port->setTimeout(1);
    connect(port, SIGNAL(readyRead()), this, SLOT(m_readAll()));
    qDebug() << "another class created";
 }

void qextserpw::handleBytesWritten(qint64 bytes)
{

}

void qextserpw::write(const QByteArray &writeData)
{
    port->write(writeData);
}

bool qextserpw::m_open(QIODevice::OpenMode mode)
{	
	bool rv=false;
    rv = port->open(mode);
    qDebug() << "port is open from another class" ;
    return rv;
}
bool qextserpw::check_open()
{	
	bool rv=false;
	rv = port->isOpen();
	return rv;
}
void qextserpw::m_readAll()
{ 
	QByteArray temp;
    temp = port->readAll();
    emit inprogress(temp);
    qDebug() << "read from another thread!";
}
void qextserpw::m_port_close()
{
    port->flush();
    port->close();
}

This class is necessary to do 2 threads - read data from qextserial and write data to qextserial

Third class to work with bar is the main class of mainwindow and called monMK:

monMK.h

#ifndef MONMK_H
#define MONMK_H
#include "qextserialport.h"
#include "qextserialport_p.h"
#include <QFileDialog>
#include <QFile>
#include <QDir>
#include <QMainWindow>
#include <QTimer>
#include "terminal.h"
#include "json.h"
#include "choicepropertiseport.h"
#include <QMainWindow>
#include <QProgressDialog>
#include <QMutex>
#include "qexception.h"
#include "qextserpw.h"
#include "terminal.h"
QT_BEGIN_NAMESPACE
namespace Ui { class monMK; }
QT_END_NAMESPACE

class monMK : public QMainWindow
{
    Q_OBJECT

public:
    explicit monMK(QWidget *parent = 0);
    ~monMK();
    unsigned long fls = 0 ;
    QString dir_c_g;
    QByteArray qbag = "{ \
                         \"PORT\": \"COM3\", \
                         \"RATE\": \"115200\", \
                         \"PARITY\": \"0\", \
                         \"STOPBIT\": \"2\", \
                         \"BITS\": \"8\", \
                         \"LD_ADDR\": \"FFFFFFFFB5000020\", \
                         \"ST_ADDR\": \"FFFFFFFFB5000020\", \
                         \"MEM_TYPE\": \"LWord\", \
                         \"MEM_ADDR\": \"FFFFFFFFB5000000\", \
                         \"FILE_LOAD\": \"C:\" \
                         }";
    ChoicePropertisePort *dialogPort = new ChoicePropertisePort;
    JSON *fs2 = new JSON();
    QProgressDialog *bar = new QProgressDialog(this);
    char mu;
    int div ;
    int mod ;
    QByteArray y;     
    QString g_LD_ADDR;
    QString g_ST_ADDR ;
    QString g_FILE_LOAD ;
    QString g_PORT ;
    QString g_RATE ;
    QString g_PARITY;
    QString g_STOPBIT;
    QString temps;
    DataBitsType g_BITS ;
    
qextserpw  *qextser = new qextserpw();
    unsigned char glb = 0;
    unsigned char  globalf ;
    QByteArray charBuffer;
    quint32 crc_32;
    QString g_portname;
    void CreateProgresswin();
    Terminal *textTerminal = new Terminal();
;
QByteArray arr;
    //
    typedef struct {
        uint8_t prefix = 0xFF;
        uint8_t code = 0x00;
    } restart_t;

    //
    typedef struct {
        uint8_t prefix = 0xFF;
        uint8_t code = 0x01;
        uint64_t start_addr = 0xFFFFFFFFB5000020;
    } start_t;
    //
    typedef struct {
        uint8_t prefix = 0xFF;
        uint8_t code = 0x02;
        uint64_t load_addr = 0xFFFFFFFFB5000020;
        uint32_t data_len = 0x00000000;
        uint8_t* data;
    } write_RAM_t;
  start_t start;
  write_RAM_t writeRAM;
protected:
void closeEvent(QCloseEvent *event);    
public slots:
void readData(QByteArray data);

private slots:
    void on_pB_propertiseCOM_clicked();
    void on_open_folder_clicked();
    void on_start_clicked();
    void on_load_clicked();
    void on_loadnstart_clicked();
    void on_restart_clicked();
    void writeData(qint64);
    void JFS(int value);
    void on_pushButton_6_clicked();
    void on_lineEdit_3_cursorPositionChanged(int arg1, int arg2);
    void on_lineEdit_2_cursorPositionChanged(int arg1, int arg2);

private:
    Ui::monMK *ui;
};
#endif // MONMK_H

monMK.c

#include "monmk.h"
#include "ui_monmk.h"
#include "choicepropertiseport.h"
#include <QtDebug>
#include <QDesktopWidget>
#include <QDateTime>
#include <QMessageBox>
#include <QLabel>
#include <QtGlobal>
#include <QtCore>
#include <QtEndian>
#include <QProgressDialog>
#include <QJsonDocument>
#include <QDir>
#include <QFileDialog>
#include <json.h>
#include "crc32.h"
#include <QString>
#include <QByteArray>
#include <qextserialport_p.h>
#include <QDebug>
#include <qextserpw.h>

monMK::monMK(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::monMK)
{
    ui->setupUi(this);
    this->setFixedSize(this->geometry().width(),this->geometry().height()); // set fixed size
    start_t start_st;
    ui->label_4->setPixmap(QPixmap(":/images/title.png"));
    textTerminal->setWindowTitle("PortTerminal");
    textTerminal->setGeometry(1156, 341, 382, 282);
    textTerminal->show();
    ui->pushButton_5->setEnabled(false);
    connect(qextser, SIGNAL(towrite()), this, SLOT(writeData())); 						// for writing 
    connect(qextser, SIGNAL( inprogress(QByteArray data) ), this, SLOT( readData(QByteArray  data))); 	// for reading
	
  ....
  ...
  ..

}
void monMK::writeData()
{
    //bar->setValue(ii);
	unsigned long ii;
    bar->setRange(1, fls-1); // 
    for(ii=0;ii<fls;ii++)
    {
      // bar->setValue(ii);
      y = arr.mid(ii, 1 );     //
      //port->write(y,1);
      qextser->write(y);//,1);
      bar->setValue(ii);
      qDebug() << "ii progress bar value" << ii;

}

void monMK::readData(QByteArray data)
{
    qDebug() << "ready read";
	textTerminal->insert_Text(data);//addText(data);
    qDebug() << "working";
}



void monMK::writeButton_clicked()
{
    QByteArray y;     // y == "pine"
    QByteArray z;
    if (!file.open(QIODevice::ReadOnly))	
    {
        QMessageBox::information(this, tr("can't open the file"),
        file.errorString());
        return;
    }
    else
     {
		qDebug() << "opening file";
		fls = file.size();
		arr.resize(fls);
		qDebug() << "size of" << fls;
		for(unsigned long i; i<fls;i++)
		{arr = 0;}
		if( arr.isEmpty())
		qDebug() << "at first array is empty";
		else
		qDebug() <<  "at first array isn't empty";
		arr = file.readAll();
		div = fls / 100;
		mod = fls % 100;
		file.close();
		QString str3 = "";
		str3.append(arr);
		textTerminal->insert_Text(str3);//addText(data);
		qDebug() << "closing file";
		qDebug() << "array from file" ;
		QString str2 = "";
		str2.append(arr);
		if( arr.isEmpty())
		qDebug() << "array is empty";
		else
		qDebug() <<  "array isn't empty";
     }


        if(qextser->status_port)
         //if(port->isOpen())
         {
           	emit qextser->towrite();
           }

         

}

Also I have got another window for terminal(serial data printing) - textTerminal

The problem in new version is I even can read data now
In debug I see whese lines :
"
another class created
read from another thread!
"
But in readData I do not run

I suppose what is something is wrong in trasnferring signal from one class to another
But It seems be right

Please help

[Pl45m4]

@another_one said in qextserialport write and progress bar:

connect(port, SIGNAL(readyRead()), this, SLOT(m_readAll()));

Was about to write something about that line, then I realized, it's not wrong (at least technically).
Please, do not name your slots m_xxxxx, it will confuse everyone who's reading your code and eventually trying to help.
After "name conventions" m_<someName> is for class member variables. Better dont name a function in a way like this.

Then, unless you're using Qt4, which I hope you dont, move to the Qt5+ connect syntax, where you use function pointers instead of string-based signal/slot keywords.

// old
connect(port, SIGNAL(readyRead()), this, SLOT(m_readAll()));

// better, for example:
connect(port, &QextSerialPort::readyRead, this, &qextserpw::onPortReadReady); // onPortReadReady instead of "m_readAll"

For your ProgressBar:

Have a look at this again, and at what @SGaist has written here