Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. Mobile and Embedded
  4. Receive data with UDP protocol
Forum Updated to NodeBB v4.3 + New Features

Receive data with UDP protocol

Scheduled Pinned Locked Moved Solved Mobile and Embedded
qtudp receive
25 Posts 3 Posters 4.5k Views 1 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • S Offline
    S Offline
    swansorter
    wrote on 8 Sept 2020, 09:23 last edited by
    #1

    hello,
    i want all received data to be stored in bytearray but in bytearray only last bunch of data are stored,is ther any way to store all the data in a array
    This is my UDP receive progrm:-
    connect(mSocket,&QUdpSocket::readyRead,&{
    if(mSocket->hasPendingDatagrams())
    {
    QByteArray data1 ;
    datagram1.resize(mSocket->pendingDatagramSize());
    QDataStream str(&datagram1, QIODevice::ReadOnly);
    mSocket->readDatagram(datagram1.data(),datagram1.size() );
    ui->textEdit->append(QString(datagram1.toHex()));

    }
    });

    J K 2 Replies Last reply 8 Sept 2020, 10:26
    0
    • S swansorter
      8 Sept 2020, 09:23

      hello,
      i want all received data to be stored in bytearray but in bytearray only last bunch of data are stored,is ther any way to store all the data in a array
      This is my UDP receive progrm:-
      connect(mSocket,&QUdpSocket::readyRead,&{
      if(mSocket->hasPendingDatagrams())
      {
      QByteArray data1 ;
      datagram1.resize(mSocket->pendingDatagramSize());
      QDataStream str(&datagram1, QIODevice::ReadOnly);
      mSocket->readDatagram(datagram1.data(),datagram1.size() );
      ui->textEdit->append(QString(datagram1.toHex()));

      }
      });

      J Online
      J Online
      JonB
      wrote on 8 Sept 2020, 10:26 last edited by JonB 9 Aug 2020, 10:28
      #2

      @swansorter
      This appends whatever it receives as hex to the text edit. How many times is it called? Why are you using UDP? If you use UDP, there is no guarantee all data will arrive, that's the point of UDP.

      QDataStream str(&datagram1, QIODevice::ReadOnly);
      

      This line does not seem to do anything, so maybe remove it.

      Your lambda only does one datagram read per each readyRead(); but at least in principle you could receive a stream of datagrams for one readyRead(), and it won't activate readRead() again if you fail to read all of them.. I think you should change your if to a while?

      S 1 Reply Last reply 8 Sept 2020, 10:44
      1
      • J JonB
        8 Sept 2020, 10:26

        @swansorter
        This appends whatever it receives as hex to the text edit. How many times is it called? Why are you using UDP? If you use UDP, there is no guarantee all data will arrive, that's the point of UDP.

        QDataStream str(&datagram1, QIODevice::ReadOnly);
        

        This line does not seem to do anything, so maybe remove it.

        Your lambda only does one datagram read per each readyRead(); but at least in principle you could receive a stream of datagrams for one readyRead(), and it won't activate readRead() again if you fail to read all of them.. I think you should change your if to a while?

        S Offline
        S Offline
        swansorter
        wrote on 8 Sept 2020, 10:44 last edited by
        #3

        @JonB I am using udp to read image sensor values
        i want receive 2014080bytes

        J 1 Reply Last reply 8 Sept 2020, 10:48
        0
        • S swansorter
          8 Sept 2020, 10:44

          @JonB I am using udp to read image sensor values
          i want receive 2014080bytes

          J Online
          J Online
          JonB
          wrote on 8 Sept 2020, 10:48 last edited by
          #4

          @swansorter
          Your comment does not address what I have said. And the fact remains that you may miss some UDP datagrams. Did you try the code change I mentioned?

          S 1 Reply Last reply 8 Sept 2020, 10:51
          0
          • J JonB
            8 Sept 2020, 10:48

            @swansorter
            Your comment does not address what I have said. And the fact remains that you may miss some UDP datagrams. Did you try the code change I mentioned?

            S Offline
            S Offline
            swansorter
            wrote on 8 Sept 2020, 10:51 last edited by
            #5

            @JonB sir i changed the if to while and i am able to recieve all the data

            J 1 Reply Last reply 8 Sept 2020, 10:53
            0
            • S swansorter
              8 Sept 2020, 10:51

              @JonB sir i changed the if to while and i am able to recieve all the data

              J Online
              J Online
              JonB
              wrote on 8 Sept 2020, 10:53 last edited by
              #6

              @swansorter
              :)

              S 1 Reply Last reply 8 Sept 2020, 10:59
              0
              • J JonB
                8 Sept 2020, 10:53

                @swansorter
                :)

                S Offline
                S Offline
                swansorter
                wrote on 8 Sept 2020, 10:59 last edited by
                #7

                @JonB how to store incommming data

                J 1 Reply Last reply 8 Sept 2020, 11:02
                0
                • S swansorter
                  8 Sept 2020, 10:59

                  @JonB how to store incommming data

                  J Online
                  J Online
                  JonB
                  wrote on 8 Sept 2020, 11:02 last edited by JonB 9 Aug 2020, 11:02
                  #8

                  @swansorter
                  Which direction "incoming"? Assuming you mean as per the code you already have, you need to stop using a local variable QByteArray data1 and instead use, say, a class variable one, so that you can append all the data arriving to it, like you do with your text edit.

                  1 Reply Last reply
                  0
                  • S swansorter
                    8 Sept 2020, 09:23

                    hello,
                    i want all received data to be stored in bytearray but in bytearray only last bunch of data are stored,is ther any way to store all the data in a array
                    This is my UDP receive progrm:-
                    connect(mSocket,&QUdpSocket::readyRead,&{
                    if(mSocket->hasPendingDatagrams())
                    {
                    QByteArray data1 ;
                    datagram1.resize(mSocket->pendingDatagramSize());
                    QDataStream str(&datagram1, QIODevice::ReadOnly);
                    mSocket->readDatagram(datagram1.data(),datagram1.size() );
                    ui->textEdit->append(QString(datagram1.toHex()));

                    }
                    });

                    K Offline
                    K Offline
                    KroMignon
                    wrote on 8 Sept 2020, 13:15 last edited by
                    #9

                    @swansorter said in Receive data with UDP protocol:

                    This is my UDP receive progrm:-
                    connect(mSocket,&QUdpSocket::readyRead,&{
                    if(mSocket->hasPendingDatagrams())
                    {
                    QByteArray data1 ;
                    datagram1.resize(mSocket->pendingDatagramSize());
                    QDataStream str(&datagram1, QIODevice::ReadOnly);
                    mSocket->readDatagram(datagram1.data(),datagram1.size() );
                    ui->textEdit->append(QString(datagram1.toHex()));
                    }
                    });

                    This can not work!
                    a. you have to change the if statement into while, to ensure you will handle all received datagram
                    b. you copy the data bunch into a local variable, which will be lost after if statement, you have to define a class member to store the different payloads

                    For example like this:

                    connect(mSocket,&QUdpSocket::readyRead, [this]() {
                        while(mSocket->hasPendingDatagrams())
                        {
                            QByteArray datagram(mSocket->pendingDatagramSize(), 0);
                            mSocket->readDatagram(datagram.data(), datagram.size() );
                            ui->textEdit->append(QString(datagram.toHex()));
                    
                            // I suppose the class contains a member mPayload which is a QByteArray
                            mPayload.append(datagram);
                         }
                    });
                    

                    Now you have to know when data is completely received ;)

                    It is an old maxim of mine that when you have excluded the impossible, whatever remains, however improbable, must be the truth. (Sherlock Holmes)

                    S 1 Reply Last reply 10 Sept 2020, 04:56
                    1
                    • K KroMignon
                      8 Sept 2020, 13:15

                      @swansorter said in Receive data with UDP protocol:

                      This is my UDP receive progrm:-
                      connect(mSocket,&QUdpSocket::readyRead,&{
                      if(mSocket->hasPendingDatagrams())
                      {
                      QByteArray data1 ;
                      datagram1.resize(mSocket->pendingDatagramSize());
                      QDataStream str(&datagram1, QIODevice::ReadOnly);
                      mSocket->readDatagram(datagram1.data(),datagram1.size() );
                      ui->textEdit->append(QString(datagram1.toHex()));
                      }
                      });

                      This can not work!
                      a. you have to change the if statement into while, to ensure you will handle all received datagram
                      b. you copy the data bunch into a local variable, which will be lost after if statement, you have to define a class member to store the different payloads

                      For example like this:

                      connect(mSocket,&QUdpSocket::readyRead, [this]() {
                          while(mSocket->hasPendingDatagrams())
                          {
                              QByteArray datagram(mSocket->pendingDatagramSize(), 0);
                              mSocket->readDatagram(datagram.data(), datagram.size() );
                              ui->textEdit->append(QString(datagram.toHex()));
                      
                              // I suppose the class contains a member mPayload which is a QByteArray
                              mPayload.append(datagram);
                           }
                      });
                      

                      Now you have to know when data is completely received ;)

                      S Offline
                      S Offline
                      swansorter
                      wrote on 10 Sept 2020, 04:56 last edited by
                      #10

                      modules:composer.user_said_in, @KroMignon, Receive data with UDP protocol

                      mPayload

                      mPayload will give segmentation fault if i use out side

                      K 1 Reply Last reply 10 Sept 2020, 05:36
                      0
                      • S swansorter
                        10 Sept 2020, 04:56

                        modules:composer.user_said_in, @KroMignon, Receive data with UDP protocol

                        mPayload

                        mPayload will give segmentation fault if i use out side

                        K Offline
                        K Offline
                        KroMignon
                        wrote on 10 Sept 2020, 05:36 last edited by
                        #11

                        @swansorter said in Receive data with UDP protocol:

                        mPayload will give segmentation fault if i use out side

                        Can you give more details about what you are doing and the debugger backtrace?

                        It is an old maxim of mine that when you have excluded the impossible, whatever remains, however improbable, must be the truth. (Sherlock Holmes)

                        S 2 Replies Last reply 10 Sept 2020, 05:42
                        0
                        • K KroMignon
                          10 Sept 2020, 05:36

                          @swansorter said in Receive data with UDP protocol:

                          mPayload will give segmentation fault if i use out side

                          Can you give more details about what you are doing and the debugger backtrace?

                          S Offline
                          S Offline
                          swansorter
                          wrote on 10 Sept 2020, 05:42 last edited by
                          #12

                          @KroMignon
                          1.i want to receive 2014080 bytes
                          2.Receiving it bunch by bunch
                          3.problem is each time i receive data the datagram1(bytearry )updated with new bunch of data and qstring also,so at last i only get last bunch of data.
                          4. i tried using global variable qstring it receives all the data but giving (SEGMENTATION FAULT).
                          is there any other way to do it .

                          this is my udp receive program
                          void MainWindow::readPendingDatagrams()
                          {
                          while(mSocket->hasPendingDatagrams())
                          {
                          QString received_data_x;
                          QByteArray datagram1;
                          datagram1.resize(mSocket->pendingDatagramSize());
                          mSocket->readDatagram(datagram1.data(),datagram1.size() );
                          received_data_x.append(datagram1.toHex());

                          }

                          }

                          S K 2 Replies Last reply 10 Sept 2020, 05:50
                          0
                          • S swansorter
                            10 Sept 2020, 05:42

                            @KroMignon
                            1.i want to receive 2014080 bytes
                            2.Receiving it bunch by bunch
                            3.problem is each time i receive data the datagram1(bytearry )updated with new bunch of data and qstring also,so at last i only get last bunch of data.
                            4. i tried using global variable qstring it receives all the data but giving (SEGMENTATION FAULT).
                            is there any other way to do it .

                            this is my udp receive program
                            void MainWindow::readPendingDatagrams()
                            {
                            while(mSocket->hasPendingDatagrams())
                            {
                            QString received_data_x;
                            QByteArray datagram1;
                            datagram1.resize(mSocket->pendingDatagramSize());
                            mSocket->readDatagram(datagram1.data(),datagram1.size() );
                            received_data_x.append(datagram1.toHex());

                            }

                            }

                            S Offline
                            S Offline
                            swansorter
                            wrote on 10 Sept 2020, 05:50 last edited by
                            #13

                            @swansorter if i use class member global variable it gives me a segmentation fault

                            void MainWindow::on_pushButton_2_pressed()
                            {
                            //if iuse class member or global variable;
                            QString test= received_data//class member;
                            int width = 2098, height = 240;
                            int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
                            QImage img(width, height, QImage::Format_RGB888);
                            QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());

                               for (int packet = 0; packet < cmd.length(); packet++)
                               {
                            

                            //in this loop am getting segmentation fault*///
                            Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;

                                   bufpo0 = bufpo0 + 4;
                                   bufpo1 = bufpo1 + 4;
                                   bufpo2 = bufpo2 + 4;
                                   bufpo3 = bufpo3 + 4;
                               }
                            
                            
                            
                               for (int y = 0; y < height; y++)
                               {
                                   for (int x = 0; x < width; x++)
                                   {
                                        QRgb value = qRgb((Auto_image_RGBdata[x] >> 22 & 0x000000ff),   Auto_image_RGBdata[x] >> 12 & 0x000000ff), (Auto_image_RGBdata[x]>>2  & 0x000003ff));
                                       img.setPixel(x,y,value);
                                   }
                               }
                               ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));
                            

                            ui->port->setScaledContents(true); QPixmap::fromImage(img.scaled(width/4,height*2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");

                            }

                            1 Reply Last reply
                            0
                            • S swansorter
                              10 Sept 2020, 05:42

                              @KroMignon
                              1.i want to receive 2014080 bytes
                              2.Receiving it bunch by bunch
                              3.problem is each time i receive data the datagram1(bytearry )updated with new bunch of data and qstring also,so at last i only get last bunch of data.
                              4. i tried using global variable qstring it receives all the data but giving (SEGMENTATION FAULT).
                              is there any other way to do it .

                              this is my udp receive program
                              void MainWindow::readPendingDatagrams()
                              {
                              while(mSocket->hasPendingDatagrams())
                              {
                              QString received_data_x;
                              QByteArray datagram1;
                              datagram1.resize(mSocket->pendingDatagramSize());
                              mSocket->readDatagram(datagram1.data(),datagram1.size() );
                              received_data_x.append(datagram1.toHex());

                              }

                              }

                              K Offline
                              K Offline
                              KroMignon
                              wrote on 10 Sept 2020, 05:53 last edited by
                              #14

                              @swansorter said in Receive data with UDP protocol:

                              this is my udp receive program
                              void MainWindow::readPendingDatagrams()
                              {
                              while(mSocket->hasPendingDatagrams())
                              {
                              QString received_data_x;
                              QByteArray datagram1;
                              datagram1.resize(mSocket->pendingDatagramSize());
                              mSocket->readDatagram(datagram1.data(),datagram1.size() );
                              received_data_x.append(datagram1.toHex());
                              }
                              }

                              once again received_data_x is a local variable not a class member!

                              It is an old maxim of mine that when you have excluded the impossible, whatever remains, however improbable, must be the truth. (Sherlock Holmes)

                              S 1 Reply Last reply 10 Sept 2020, 05:59
                              1
                              • K KroMignon
                                10 Sept 2020, 05:53

                                @swansorter said in Receive data with UDP protocol:

                                this is my udp receive program
                                void MainWindow::readPendingDatagrams()
                                {
                                while(mSocket->hasPendingDatagrams())
                                {
                                QString received_data_x;
                                QByteArray datagram1;
                                datagram1.resize(mSocket->pendingDatagramSize());
                                mSocket->readDatagram(datagram1.data(),datagram1.size() );
                                received_data_x.append(datagram1.toHex());
                                }
                                }

                                once again received_data_x is a local variable not a class member!

                                S Offline
                                S Offline
                                swansorter
                                wrote on 10 Sept 2020, 05:59 last edited by
                                #15

                                @KroMignon if i use received_data_x as class member i am getting segmentation fault

                                K 1 Reply Last reply 10 Sept 2020, 06:19
                                0
                                • K KroMignon
                                  10 Sept 2020, 05:36

                                  @swansorter said in Receive data with UDP protocol:

                                  mPayload will give segmentation fault if i use out side

                                  Can you give more details about what you are doing and the debugger backtrace?

                                  S Offline
                                  S Offline
                                  swansorter
                                  wrote on 10 Sept 2020, 06:07 last edited by
                                  #16

                                  @KroMignon
                                  28621 [1] {
                                  0x55555562d82c 55 push %rbp
                                  0x55555562d82d <+0x0001> 48 89 e5 mov %rsp,%rbp
                                  0x55555562d830 <+0x0004> 53 push %rbx
                                  0x55555562d831 <+0x0005> 48 81 ec d8 00 00 00 sub $0xd8,%rsp
                                  0x55555562d838 <+0x000c> 48 89 bd 28 ff ff ff mov %rdi,-0xd8(%rbp)
                                  0x55555562d83f <+0x0013> 64 48 8b 04 25 28 00 00 00 mov %fs:0x28,%rax
                                  0x55555562d848 <+0x001c> 48 89 45 e8 mov %rax,-0x18(%rbp)
                                  0x55555562d84c <+0x0020> 31 c0 xor %eax,%eax
                                  28635 [1] QString test= x_member;
                                  0x55555562d84e <+0x0022> 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
                                  0x55555562d855 <+0x0029> 48 8d 90 88 02 00 00 lea 0x288(%rax),%rdx
                                  0x55555562d85c <+0x0030> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
                                  0x55555562d863 <+0x0037> 48 89 d6 mov %rdx,%rsi
                                  0x55555562d866 <+0x003a> 48 89 c7 mov %rax,%rdi
                                  0x55555562d869 <+0x003d> e8 26 52 00 00 callq 0x555555632a94 <QString::QString(QString const&)>
                                  28636 [1] int width = 2098, height = 240;
                                  0x55555562d86e <+0x0042> c7 85 5c ff ff ff 32 08 00 00 movl $0x832,-0xa4(%rbp)
                                  0x55555562d878 <+0x004c> c7 85 60 ff ff ff f0 00 00 00 movl $0xf0,-0xa0(%rbp)
                                  28637 [1] int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
                                  0x55555562d882 <+0x0056> c7 85 40 ff ff ff 00 00 00 00 movl $0x0,-0xc0(%rbp)
                                  0x55555562d88c <+0x0060> c7 85 44 ff ff ff 01 00 00 00 movl $0x1,-0xbc(%rbp)
                                  0x55555562d896 <+0x006a> c7 85 48 ff ff ff 02 00 00 00 movl $0x2,-0xb8(%rbp)
                                  0x55555562d8a0 <+0x0074> c7 85 4c ff ff ff 03 00 00 00 movl $0x3,-0xb4(%rbp)
                                  28638 [1] QImage img(width, height, QImage::Format_RGB888);
                                  0x55555562d8aa <+0x007e> 8b 95 60 ff ff ff mov -0xa0(%rbp),%edx
                                  0x55555562d8b0 <+0x0084> 8b b5 5c ff ff ff mov -0xa4(%rbp),%esi
                                  0x55555562d8b6 <+0x008a> 48 8d 45 80 lea -0x80(%rbp),%rax
                                  0x55555562d8ba <+0x008e> b9 0d 00 00 00 mov $0xd,%ecx
                                  0x55555562d8bf <+0x0093> 48 89 c7 mov %rax,%rdi
                                  0x55555562d8c2 <+0x0096> e8 19 f4 f2 ff callq 0x55555555cce0 _ZN6QImageC1EiiNS_6FormatE@plt
                                  28639 [1] QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
                                  0x55555562d8c7 <+0x009b> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562d8cb <+0x009f> 48 8d 35 06 05 0d 00 lea 0xd0506(%rip),%rsi # 0x5555556fddd8
                                  0x55555562d8d2 <+0x00a6> 48 89 c7 mov %rax,%rdi
                                  0x55555562d8d5 <+0x00a9> e8 be 4e 00 00 callq 0x555555632798 <QString::QString(char const*)>
                                  0x55555562d8da <+0x00ae> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562d8e1 <+0x00b5> 48 8d 35 c8 7e 0d 00 lea 0xd7ec8(%rip),%rsi # 0x5555557057b0
                                  0x55555562d8e8 <+0x00bc> 48 89 c7 mov %rax,%rdi
                                  0x55555562d8eb <+0x00bf> e8 a8 4e 00 00 callq 0x555555632798 <QString::QString(char const*)>
                                  0x55555562d8f0 <+0x00c4> 48 8d 55 a0 lea -0x60(%rbp),%rdx
                                  0x55555562d8f4 <+0x00c8> 48 8d b5 78 ff ff ff lea -0x88(%rbp),%rsi
                                  0x55555562d8fb <+0x00cf> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
                                  0x55555562d902 <+0x00d6> b9 01 00 00 00 mov $0x1,%ecx
                                  0x55555562d907 <+0x00db> 48 89 c7 mov %rax,%rdi
                                  0x55555562d90a <+0x00de> e8 b1 fc f2 ff callq 0x55555555d5c0 _ZN7QString7replaceERKS_S1_N2Qt15CaseSensitivityE@plt
                                  0x55555562d90f <+0x00e3> 48 89 c2 mov %rax,%rdx
                                  0x55555562d912 <+0x00e6> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562d916 <+0x00ea> 48 89 d6 mov %rdx,%rsi
                                  0x55555562d919 <+0x00ed> 48 89 c7 mov %rax,%rdi
                                  0x55555562d91c <+0x00f0> e8 83 4c 00 00 callq 0x5555556325a4 <QString::toLatin1() const &>
                                  0x55555562d921 <+0x00f5> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562d928 <+0x00fc> 48 8d 55 c0 lea -0x40(%rbp),%rdx
                                  0x55555562d92c <+0x0100> 48 89 d6 mov %rdx,%rsi
                                  0x55555562d92f <+0x0103> 48 89 c7 mov %rax,%rdi
                                  0x55555562d932 <+0x0106> e8 39 f4 f2 ff callq 0x55555555cd70 _ZN10QByteArray7fromHexERKS_@plt
                                  0x55555562d937 <+0x010b> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562d93b <+0x010f> 48 89 c7 mov %rax,%rdi
                                  0x55555562d93e <+0x0112> e8 11 00 f3 ff callq 0x55555555d954 QByteArray::~QByteArray()
                                  0x55555562d943 <+0x0117> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562d94a <+0x011e> 48 89 c7 mov %rax,%rdi
                                  0x55555562d94d <+0x0121> e8 b8 51 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562d952 <+0x0126> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562d956 <+0x012a> 48 89 c7 mov %rax,%rdi
                                  0x55555562d959 <+0x012d> e8 ac 51 00 00 callq 0x555555632b0a QString::~QString()
                                  28643 [1] for (int packet = 0; packet < cmd.length(); packet++)//2098100(lines)=540000packets
                                  0x55555562d95e <+0x0132> c7 85 50 ff ff ff 00 00 00 00 movl $0x0,-0xb0(%rbp)
                                  0x55555562d968 <+0x013c> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562d96f <+0x0143> 48 89 c7 mov %rax,%rdi
                                  0x55555562d972 <+0x0146> e8 71 49 00 00 callq 0x5555556322e8 <QByteArray::length() const>
                                  0x55555562d977 <+0x014b> 39 85 50 ff ff ff cmp %eax,-0xb0(%rbp)
                                  0x55555562d97d <+0x0151> 0f 9c c0 setl %al
                                  0x55555562d980 <+0x0154> 84 c0 test %al,%al
                                  0x55555562d982 <+0x0156> 0f 84 d8 00 00 00 je 0x55555562da60 MainWindow::on_pushButton_2_pressed()+564
                                  28648 [1] Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;
                                  0x55555562d988 <+0x015c> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562d98f <+0x0163> 48 89 c7 mov %rax,%rdi
                                  0x55555562d992 <+0x0166> e8 97 49 00 00 callq 0x55555563232e QByteArray::data()
                                  0x55555562d997 <+0x016b> 48 89 c2 mov %rax,%rdx
                                  0x55555562d99a <+0x016e> 8b 85 40 ff ff ff mov -0xc0(%rbp),%eax
                                  0x55555562d9a0 <+0x0174> 48 98 cltq
                                  0x55555562d9a2 <+0x0176> 48 01 d0 add %rdx,%rax
                                  0x55555562d9a5 <+0x0179> 0f b6 00 movzbl (%rax),%eax
                                  0x55555562d9a8 <+0x017c> 0f b6 d8 movzbl %al,%ebx
                                  0x55555562d9ab <+0x017f> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562d9b2 <+0x0186> 48 89 c7 mov %rax,%rdi
                                  0x55555562d9b5 <+0x0189> e8 74 49 00 00 callq 0x55555563232e QByteArray::data()
                                  0x55555562d9ba <+0x018e> 48 89 c2 mov %rax,%rdx
                                  0x55555562d9bd <+0x0191> 8b 85 44 ff ff ff mov -0xbc(%rbp),%eax
                                  0x55555562d9c3 <+0x0197> 48 98 cltq
                                  0x55555562d9c5 <+0x0199> 48 01 d0 add %rdx,%rax
                                  0x55555562d9c8 <+0x019c> 0f b6 00 movzbl (%rax),%eax
                                  0x55555562d9cb <+0x019f> 0f b6 c0 movzbl %al,%eax
                                  0x55555562d9ce <+0x01a2> c1 e0 08 shl $0x8,%eax
                                  0x55555562d9d1 <+0x01a5> 09 c3 or %eax,%ebx
                                  0x55555562d9d3 <+0x01a7> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562d9da <+0x01ae> 48 89 c7 mov %rax,%rdi
                                  0x55555562d9dd <+0x01b1> e8 4c 49 00 00 callq 0x55555563232e QByteArray::data()
                                  0x55555562d9e2 <+0x01b6> 48 89 c2 mov %rax,%rdx
                                  0x55555562d9e5 <+0x01b9> 8b 85 48 ff ff ff mov -0xb8(%rbp),%eax
                                  0x55555562d9eb <+0x01bf> 48 98 cltq
                                  0x55555562d9ed <+0x01c1> 48 01 d0 add %rdx,%rax
                                  0x55555562d9f0 <+0x01c4> 0f b6 00 movzbl (%rax),%eax
                                  0x55555562d9f3 <+0x01c7> 0f b6 c0 movzbl %al,%eax
                                  0x55555562d9f6 <+0x01ca> c1 e0 10 shl $0x10,%eax
                                  0x55555562d9f9 <+0x01cd> 09 c3 or %eax,%ebx
                                  0x55555562d9fb <+0x01cf> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562da02 <+0x01d6> 48 89 c7 mov %rax,%rdi
                                  0x55555562da05 <+0x01d9> e8 24 49 00 00 callq 0x55555563232e QByteArray::data()
                                  0x55555562da0a <+0x01de> 48 89 c2 mov %rax,%rdx
                                  0x55555562da0d <+0x01e1> 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
                                  0x55555562da13 <+0x01e7> 48 98 cltq
                                  0x55555562da15 <+0x01e9> 48 01 d0 add %rdx,%rax
                                  0x55555562da18 <+0x01ec> 0f b6 00 movzbl (%rax),%eax
                                  0x55555562da1b <+0x01ef> 0f b6 c0 movzbl %al,%eax
                                  0x55555562da1e <+0x01f2> c1 e0 18 shl $0x18,%eax
                                  0x55555562da21 <+0x01f5> 89 d9 mov %ebx,%ecx
                                  0x55555562da23 <+0x01f7> 09 c1 or %eax,%ecx
                                  0x55555562da25 <+0x01f9> 48 8d 05 74 a5 3a 00 lea 0x3aa574(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
                                  0x55555562da2c <+0x0200> 8b 95 50 ff ff ff mov -0xb0(%rbp),%edx
                                  0x55555562da32 <+0x0206> 48 63 d2 movslq %edx,%rdx
                                  0x55555562da35 <+0x0209> 89 0c 90 mov %ecx,(%rax,%rdx,4)
                                  28658 [1] bufpo0 = bufpo0 + 4;
                                  0x55555562da38 <+0x020c> 83 85 40 ff ff ff 04 addl $0x4,-0xc0(%rbp)
                                  28659 [1] bufpo1 = bufpo1 + 4;
                                  0x55555562da3f <+0x0213> 83 85 44 ff ff ff 04 addl $0x4,-0xbc(%rbp)
                                  28660 [1] bufpo2 = bufpo2 + 4;
                                  0x55555562da46 <+0x021a> 83 85 48 ff ff ff 04 addl $0x4,-0xb8(%rbp)
                                  28661 [1] bufpo3 = bufpo3 + 4;
                                  0x55555562da4d <+0x0221> 83 85 4c ff ff ff 04 addl $0x4,-0xb4(%rbp)
                                  28643 [2] for (int packet = 0; packet < cmd.length(); packet++)//2098
                                  100(lines)=540000packets
                                  0x55555562da54 <+0x0228> 83 85 50 ff ff ff 01 addl $0x1,-0xb0(%rbp)
                                  0x55555562da5b <+0x022f> e9 08 ff ff ff jmpq 0x55555562d968 MainWindow::on_pushButton_2_pressed()+316
                                  28666 [1] for (int y = 0; y < height; y++)
                                  0x55555562da60 <+0x0234> c7 85 54 ff ff ff 00 00 00 00 movl $0x0,-0xac(%rbp)
                                  0x55555562da6a <+0x023e> 8b 85 54 ff ff ff mov -0xac(%rbp),%eax
                                  0x55555562da70 <+0x0244> 3b 85 60 ff ff ff cmp -0xa0(%rbp),%eax
                                  0x55555562da76 <+0x024a> 0f 8d b2 00 00 00 jge 0x55555562db2e MainWindow::on_pushButton_2_pressed()+770
                                  28669 [1] for (int x = 0; x < width; x++)
                                  0x55555562da7c <+0x0250> c7 85 58 ff ff ff 00 00 00 00 movl $0x0,-0xa8(%rbp)
                                  0x55555562da86 <+0x025a> 8b 85 58 ff ff ff mov -0xa8(%rbp),%eax
                                  0x55555562da8c <+0x0260> 3b 85 5c ff ff ff cmp -0xa4(%rbp),%eax
                                  0x55555562da92 <+0x0266> 0f 8d 8a 00 00 00 jge 0x55555562db22 MainWindow::on_pushButton_2_pressed()+758

                                  >> 22 & 0x000000ff),(Auto_image_RGBdata[x] >> 12 & 0x000000ff), (Auto_image_RGBdata[x]>>2 & 0x000003ff));

                                  0x55555562da98 <+0x026c> 48 8d 05 01 a5 3a 00 lea 0x3aa501(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
                                  0x55555562da9f <+0x0273> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
                                  0x55555562daa5 <+0x0279> 48 63 d2 movslq %edx,%rdx
                                  0x55555562daa8 <+0x027c> 8b 04 90 mov (%rax,%rdx,4),%eax
                                  0x55555562daab <+0x027f> c1 f8 02 sar $0x2,%eax
                                  0x55555562daae <+0x0282> 25 ff 03 00 00 and $0x3ff,%eax
                                  0x55555562dab3 <+0x0287> 89 c6 mov %eax,%esi
                                  0x55555562dab5 <+0x0289> 48 8d 05 e4 a4 3a 00 lea 0x3aa4e4(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
                                  0x55555562dabc <+0x0290> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
                                  0x55555562dac2 <+0x0296> 48 63 d2 movslq %edx,%rdx
                                  0x55555562dac5 <+0x0299> 8b 04 90 mov (%rax,%rdx,4),%eax
                                  0x55555562dac8 <+0x029c> c1 f8 0c sar $0xc,%eax
                                  0x55555562dacb <+0x029f> 0f b6 c8 movzbl %al,%ecx
                                  0x55555562dace <+0x02a2> 48 8d 05 cb a4 3a 00 lea 0x3aa4cb(%rip),%rax # 0x5555559d7fa0 <Auto_image_RGBdata>
                                  0x55555562dad5 <+0x02a9> 8b 95 58 ff ff ff mov -0xa8(%rbp),%edx
                                  0x55555562dadb <+0x02af> 48 63 d2 movslq %edx,%rdx
                                  0x55555562dade <+0x02b2> 8b 04 90 mov (%rax,%rdx,4),%eax
                                  0x55555562dae1 <+0x02b5> c1 f8 16 sar $0x16,%eax
                                  0x55555562dae4 <+0x02b8> 0f b6 c0 movzbl %al,%eax
                                  0x55555562dae7 <+0x02bb> 89 f2 mov %esi,%edx
                                  0x55555562dae9 <+0x02bd> 89 ce mov %ecx,%esi
                                  0x55555562daeb <+0x02bf> 89 c7 mov %eax,%edi
                                  0x55555562daed <+0x02c1> e8 ff 56 00 00 callq 0x5555556331f1 <qRgb(int, int, int)>
                                  0x55555562daf2 <+0x02c6> 89 85 64 ff ff ff mov %eax,-0x9c(%rbp)
                                  28672 [1] img.setPixel(x,y,value);
                                  0x55555562daf8 <+0x02cc> 8b 8d 64 ff ff ff mov -0x9c(%rbp),%ecx
                                  0x55555562dafe <+0x02d2> 8b 95 54 ff ff ff mov -0xac(%rbp),%edx
                                  0x55555562db04 <+0x02d8> 8b b5 58 ff ff ff mov -0xa8(%rbp),%esi
                                  0x55555562db0a <+0x02de> 48 8d 45 80 lea -0x80(%rbp),%rax
                                  0x55555562db0e <+0x02e2> 48 89 c7 mov %rax,%rdi
                                  0x55555562db11 <+0x02e5> e8 aa f0 f2 ff callq 0x55555555cbc0 _ZN6QImage8setPixelEiij@plt
                                  28669 [2] for (int x = 0; x < width; x++)
                                  0x55555562db16 <+0x02ea> 83 85 58 ff ff ff 01 addl $0x1,-0xa8(%rbp)
                                  0x55555562db1d <+0x02f1> e9 64 ff ff ff jmpq 0x55555562da86 MainWindow::on_pushButton_2_pressed()+602
                                  28666 [2] for (int y = 0; y < height; y++)
                                  0x55555562db22 <+0x02f6> 83 85 54 ff ff ff 01 addl $0x1,-0xac(%rbp)
                                  0x55555562db29 <+0x02fd> e9 3c ff ff ff jmpq 0x55555562da6a MainWindow::on_pushButton_2_pressed()+574
                                  28676 [1] ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));
                                  0x55555562db2e <+0x0302> 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
                                  0x55555562db35 <+0x0309> 48 8b 80 20 02 00 00 mov 0x220(%rax),%rax
                                  0x55555562db3c <+0x0310> 48 8b 98 90 00 00 00 mov 0x90(%rax),%rbx
                                  0x55555562db43 <+0x0317> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562db4a <+0x031e> be 00 00 00 00 mov $0x0,%esi
                                  0x55555562db4f <+0x0323> 48 89 c7 mov %rax,%rdi
                                  0x55555562db52 <+0x0326> e8 8d 44 00 00 callq 0x555555631fe4 <QFlagsQt::ImageConversionFlag::QFlags(Qt::ImageConversionFlag)>
                                  0x55555562db57 <+0x032b> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562db5b <+0x032f> 48 8d 75 80 lea -0x80(%rbp),%rsi
                                  0x55555562db5f <+0x0333> 41 b9 00 00 00 00 mov $0x0,%r9d
                                  0x55555562db65 <+0x0339> 41 b8 01 00 00 00 mov $0x1,%r8d
                                  0x55555562db6b <+0x033f> b9 2d 01 00 00 mov $0x12d,%ecx
                                  0x55555562db70 <+0x0344> ba 1d 02 00 00 mov $0x21d,%edx
                                  0x55555562db75 <+0x0349> 48 89 c7 mov %rax,%rdi
                                  0x55555562db78 <+0x034c> e8 9d 57 00 00 callq 0x55555563331a <QImage::scaled(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>
                                  0x55555562db7d <+0x0351> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562db81 <+0x0355> 8b 95 78 ff ff ff mov -0x88(%rbp),%edx
                                  0x55555562db87 <+0x035b> 48 8d 4d a0 lea -0x60(%rbp),%rcx
                                  0x55555562db8b <+0x035f> 48 89 ce mov %rcx,%rsi
                                  0x55555562db8e <+0x0362> 48 89 c7 mov %rax,%rdi
                                  0x55555562db91 <+0x0365> e8 fc 57 00 00 callq 0x555555633392 <QPixmap::fromImage(QImage&&, QFlagsQt::ImageConversionFlag)>
                                  0x55555562db96 <+0x036a> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562db9a <+0x036e> 48 89 c6 mov %rax,%rsi
                                  0x55555562db9d <+0x0371> 48 89 df mov %rbx,%rdi
                                  0x55555562dba0 <+0x0374> e8 6b f3 f2 ff callq 0x55555555cf10 _ZN6QLabel9setPixmapERK7QPixmap@plt
                                  0x55555562dba5 <+0x0379> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dba9 <+0x037d> 48 89 c7 mov %rax,%rdi
                                  0x55555562dbac <+0x0380> e8 3f ec f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
                                  0x55555562dbb1 <+0x0385> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dbb5 <+0x0389> 48 89 c7 mov %rax,%rdi
                                  0x55555562dbb8 <+0x038c> e8 33 f1 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  28677 [1] ui->port->setScaledContents(true);
                                  0x55555562dbbd <+0x0391> 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
                                  0x55555562dbc4 <+0x0398> 48 8b 80 20 02 00 00 mov 0x220(%rax),%rax
                                  0x55555562dbcb <+0x039f> 48 8b 80 90 00 00 00 mov 0x90(%rax),%rax
                                  0x55555562dbd2 <+0x03a6> be 01 00 00 00 mov $0x1,%esi
                                  0x55555562dbd7 <+0x03ab> 48 89 c7 mov %rax,%rdi
                                  0x55555562dbda <+0x03ae> e8 41 f1 f2 ff callq 0x55555555cd20 _ZN6QLabel17setScaledContentsEb@plt
                                  28679 [1] QPixmap::fromImage(img.scaled(width/4,height2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");
                                  0x55555562dbdf <+0x03b3> 48 8d 85 3c ff ff ff lea -0xc4(%rbp),%rax
                                  0x55555562dbe6 <+0x03ba> be 00 00 00 00 mov $0x0,%esi
                                  0x55555562dbeb <+0x03bf> 48 89 c7 mov %rax,%rdi
                                  0x55555562dbee <+0x03c2> e8 f1 43 00 00 callq 0x555555631fe4 <QFlagsQt::ImageConversionFlag::QFlags(Qt::ImageConversionFlag)>
                                  0x55555562dbf3 <+0x03c7> 8b 85 60 ff ff ff mov -0xa0(%rbp),%eax
                                  0x55555562dbf9 <+0x03cd> 8d 14 00 lea (%rax,%rax,1),%edx
                                  0x55555562dbfc <+0x03d0> 8b 85 5c ff ff ff mov -0xa4(%rbp),%eax
                                  0x55555562dc02 <+0x03d6> 8d 48 03 lea 0x3(%rax),%ecx
                                  0x55555562dc05 <+0x03d9> 85 c0 test %eax,%eax
                                  0x55555562dc07 <+0x03db> 0f 48 c1 cmovs %ecx,%eax
                                  0x55555562dc0a <+0x03de> c1 f8 02 sar $0x2,%eax
                                  0x55555562dc0d <+0x03e1> 89 c7 mov %eax,%edi
                                  0x55555562dc0f <+0x03e3> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dc13 <+0x03e7> 48 8d 75 80 lea -0x80(%rbp),%rsi
                                  0x55555562dc17 <+0x03eb> 41 b9 00 00 00 00 mov $0x0,%r9d
                                  0x55555562dc1d <+0x03f1> 41 b8 01 00 00 00 mov $0x1,%r8d
                                  0x55555562dc23 <+0x03f7> 89 d1 mov %edx,%ecx
                                  0x55555562dc25 <+0x03f9> 89 fa mov %edi,%edx
                                  0x55555562dc27 <+0x03fb> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc2a <+0x03fe> e8 eb 56 00 00 callq 0x55555563331a <QImage::scaled(int, int, Qt::AspectRatioMode, Qt::TransformationMode) const>
                                  0x55555562dc2f <+0x0403> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dc33 <+0x0407> 8b 95 3c ff ff ff mov -0xc4(%rbp),%edx
                                  0x55555562dc39 <+0x040d> 48 8d 4d a0 lea -0x60(%rbp),%rcx
                                  0x55555562dc3d <+0x0411> 48 89 ce mov %rcx,%rsi
                                  0x55555562dc40 <+0x0414> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc43 <+0x0417> e8 4a 57 00 00 callq 0x555555633392 <QPixmap::fromImage(QImage&&, QFlagsQt::ImageConversionFlag)>
                                  0x55555562dc48 <+0x041c> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562dc4f <+0x0423> 48 8d 35 5d 7b 0d 00 lea 0xd7b5d(%rip),%rsi # 0x5555557057b3
                                  0x55555562dc56 <+0x042a> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc59 <+0x042d> e8 3a 4b 00 00 callq 0x555555632798 <QString::QString(char const
                                  )>
                                  0x55555562dc5e <+0x0432> 48 8d b5 78 ff ff ff lea -0x88(%rbp),%rsi
                                  0x55555562dc65 <+0x0439> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dc69 <+0x043d> b9 ff ff ff ff mov $0xffffffff,%ecx
                                  0x55555562dc6e <+0x0442> 48 8d 15 49 7b 0d 00 lea 0xd7b49(%rip),%rdx # 0x5555557057be
                                  0x55555562dc75 <+0x0449> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc78 <+0x044c> e8 43 f6 f2 ff callq 0x55555555d2c0 _ZNK7QPixmap4saveERK7QStringPKci@plt
                                  0x55555562dc7d <+0x0451> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562dc84 <+0x0458> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc87 <+0x045b> e8 7e 4e 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562dc8c <+0x0460> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dc90 <+0x0464> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc93 <+0x0467> e8 58 eb f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
                                  0x55555562dc98 <+0x046c> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dc9c <+0x0470> 48 89 c7 mov %rax,%rdi
                                  0x55555562dc9f <+0x0473> e8 4c f0 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  28639 [2] QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
                                  0x55555562dca4 <+0x0478> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562dcab <+0x047f> 48 89 c7 mov %rax,%rdi
                                  0x55555562dcae <+0x0482> e8 a1 fc f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
                                  28638 [2] QImage img(width, height, QImage::Format_RGB888);
                                  0x55555562dcb3 <+0x0487> 48 8d 45 80 lea -0x80(%rbp),%rax
                                  0x55555562dcb7 <+0x048b> 48 89 c7 mov %rax,%rdi
                                  0x55555562dcba <+0x048e> e8 31 f0 f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  28635 [2] QString test= x_member;
                                  0x55555562dcbf <+0x0493> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
                                  0x55555562dcc6 <+0x049a> 48 89 c7 mov %rax,%rdi
                                  0x55555562dcc9 <+0x049d> e8 3c 4e 00 00 callq 0x555555632b0a QString::~QString()
                                  28683 [1] }
                                  0x55555562dcce <+0x04a2> 90 nop
                                  0x55555562dccf <+0x04a3> 48 8b 45 e8 mov -0x18(%rbp),%rax
                                  0x55555562dcd3 <+0x04a7> 64 48 33 04 25 28 00 00 00 xor %fs:0x28,%rax
                                  0x55555562dcdc <+0x04b0> 0f 84 da 00 00 00 je 0x55555562ddbc MainWindow::on_pushButton_2_pressed()+1424
                                  0x55555562dce2 <+0x04b6> e9 d0 00 00 00 jmpq 0x55555562ddb7 MainWindow::on_pushButton_2_pressed()+1419
                                  0x55555562dce7 <+0x04bb> 48 89 c3 mov %rax,%rbx
                                  0x55555562dcea <+0x04be> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dcee <+0x04c2> 48 89 c7 mov %rax,%rdi
                                  0x55555562dcf1 <+0x04c5> e8 5e fc f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
                                  0x55555562dcf6 <+0x04ca> eb 03 jmp 0x55555562dcfb MainWindow::on_pushButton_2_pressed()+1231
                                  0x55555562dcf8 <+0x04cc> 48 89 c3 mov %rax,%rbx
                                  0x55555562dcfb <+0x04cf> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562dd02 <+0x04d6> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd05 <+0x04d9> e8 00 4e 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562dd0a <+0x04de> eb 03 jmp 0x55555562dd0f MainWindow::on_pushButton_2_pressed()+1251
                                  0x55555562dd0c <+0x04e0> 48 89 c3 mov %rax,%rbx
                                  0x55555562dd0f <+0x04e3> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dd13 <+0x04e7> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd16 <+0x04ea> e8 ef 4d 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562dd1b <+0x04ef> eb 6f jmp 0x55555562dd8c MainWindow::on_pushButton_2_pressed()+1376
                                  0x55555562dd1d <+0x04f1> 48 89 c3 mov %rax,%rbx
                                  28676 [2] ui->port->setPixmap(QPixmap::fromImage(img.scaled(541,301,Qt::KeepAspectRatio)));
                                  0x55555562dd20 <+0x04f4> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dd24 <+0x04f8> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd27 <+0x04fb> e8 c4 ea f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
                                  0x55555562dd2c <+0x0500> eb 03 jmp 0x55555562dd31 MainWindow::on_pushButton_2_pressed()+1285
                                  0x55555562dd2e <+0x0502> 48 89 c3 mov %rax,%rbx
                                  0x55555562dd31 <+0x0505> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dd35 <+0x0509> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd38 <+0x050c> e8 b3 ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  0x55555562dd3d <+0x0511> eb 39 jmp 0x55555562dd78 MainWindow::on_pushButton_2_pressed()+1356
                                  0x55555562dd3f <+0x0513> 48 89 c3 mov %rax,%rbx
                                  28679 [2] QPixmap::fromImage(img.scaled(width/4,height*2,Qt::KeepAspectRatio)).save("image2.jpg","JPG");
                                  0x55555562dd42 <+0x0516> 48 8d 85 78 ff ff ff lea -0x88(%rbp),%rax
                                  0x55555562dd49 <+0x051d> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd4c <+0x0520> e8 b9 4d 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562dd51 <+0x0525> eb 03 jmp 0x55555562dd56 MainWindow::on_pushButton_2_pressed()+1322
                                  0x55555562dd53 <+0x0527> 48 89 c3 mov %rax,%rbx
                                  0x55555562dd56 <+0x052a> 48 8d 45 c0 lea -0x40(%rbp),%rax
                                  0x55555562dd5a <+0x052e> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd5d <+0x0531> e8 8e ea f2 ff callq 0x55555555c7f0 _ZN7QPixmapD1Ev@plt
                                  0x55555562dd62 <+0x0536> eb 03 jmp 0x55555562dd67 MainWindow::on_pushButton_2_pressed()+1339
                                  0x55555562dd64 <+0x0538> 48 89 c3 mov %rax,%rbx
                                  0x55555562dd67 <+0x053b> 48 8d 45 a0 lea -0x60(%rbp),%rax
                                  0x55555562dd6b <+0x053f> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd6e <+0x0542> e8 7d ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  0x55555562dd73 <+0x0547> eb 03 jmp 0x55555562dd78 MainWindow::on_pushButton_2_pressed()+1356
                                  0x55555562dd75 <+0x0549> 48 89 c3 mov %rax,%rbx
                                  28639 [3] QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());
                                  0x55555562dd78 <+0x054c> 48 8d 85 70 ff ff ff lea -0x90(%rbp),%rax
                                  0x55555562dd7f <+0x0553> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd82 <+0x0556> e8 cd fb f2 ff callq 0x55555555d954 QByteArray::~QByteArray()
                                  0x55555562dd87 <+0x055b> eb 03 jmp 0x55555562dd8c MainWindow::on_pushButton_2_pressed()+1376
                                  0x55555562dd89 <+0x055d> 48 89 c3 mov %rax,%rbx
                                  28638 [3] QImage img(width, height, QImage::Format_RGB888);
                                  0x55555562dd8c <+0x0560> 48 8d 45 80 lea -0x80(%rbp),%rax
                                  0x55555562dd90 <+0x0564> 48 89 c7 mov %rax,%rdi
                                  0x55555562dd93 <+0x0567> e8 58 ef f2 ff callq 0x55555555ccf0 _ZN6QImageD1Ev@plt
                                  0x55555562dd98 <+0x056c> eb 03 jmp 0x55555562dd9d MainWindow::on_pushButton_2_pressed()+1393
                                  0x55555562dd9a <+0x056e> 48 89 c3 mov %rax,%rbx
                                  28635 [3] QString test= x_member;
                                  0x55555562dd9d <+0x0571> 48 8d 85 68 ff ff ff lea -0x98(%rbp),%rax
                                  0x55555562dda4 <+0x0578> 48 89 c7 mov %rax,%rdi
                                  0x55555562dda7 <+0x057b> e8 5e 4d 00 00 callq 0x555555632b0a QString::~QString()
                                  0x55555562ddac <+0x0580> 48 89 d8 mov %rbx,%rax
                                  0x55555562ddaf <+0x0583> 48 89 c7 mov %rax,%rdi
                                  0x55555562ddb2 <+0x0586> e8 39 ee f2 ff callq 0x55555555cbf0 _Unwind_Resume@plt
                                  28683 [2] }
                                  0x55555562ddb7 <+0x058b> e8 14 ec f2 ff callq 0x55555555c9d0 __stack_chk_fail@plt
                                  0x55555562ddbc <+0x0590> 48 81 c4 d8 00 00 00 add $0xd8,%rsp
                                  0x55555562ddc3 <+0x0597> 5b pop %rbx
                                  0x55555562ddc4 <+0x0598> 5d pop %rbp
                                  0x55555562ddc5 <+0x0599> c3 retq

                                  1 Reply Last reply
                                  0
                                  • S swansorter
                                    10 Sept 2020, 05:59

                                    @KroMignon if i use received_data_x as class member i am getting segmentation fault

                                    K Offline
                                    K Offline
                                    KroMignon
                                    wrote on 10 Sept 2020, 06:19 last edited by KroMignon 9 Oct 2020, 06:57
                                    #17

                                    @swansorter said in Receive data with UDP protocol:

                                    if i use received_data_x as class member i am getting segmentation fault

                                    I don't understand this, I do this in many application running on Windows, Linux and Android and I never got a segmentation fault!

                                    class MainWindow : public QMainWindow
                                    {
                                        Q_OBJECT
                                    
                                    ...
                                       QUdpSoccket *mSocket;
                                       QByteArray mPayload;
                                    ...
                                    
                                    private slots:
                                        void readPendingDatagrams();
                                    }
                                    

                                    and then

                                    void MainWindow::readPendingDatagrams()
                                    {
                                        while(mSocket->hasPendingDatagrams())
                                        {
                                            QByteArray datagram1;
                                            datagram1.resize(mSocket->pendingDatagramSize());
                                            mSocket->readDatagram(datagram1.data(),datagram1.size() );
                                            mPayload.append(datagram1.toHex());
                                        }
                                    }
                                    

                                    And this works fine.

                                    It is an old maxim of mine that when you have excluded the impossible, whatever remains, however improbable, must be the truth. (Sherlock Holmes)

                                    S 1 Reply Last reply 10 Sept 2020, 06:29
                                    0
                                    • K KroMignon
                                      10 Sept 2020, 06:19

                                      @swansorter said in Receive data with UDP protocol:

                                      if i use received_data_x as class member i am getting segmentation fault

                                      I don't understand this, I do this in many application running on Windows, Linux and Android and I never got a segmentation fault!

                                      class MainWindow : public QMainWindow
                                      {
                                          Q_OBJECT
                                      
                                      ...
                                         QUdpSoccket *mSocket;
                                         QByteArray mPayload;
                                      ...
                                      
                                      private slots:
                                          void readPendingDatagrams();
                                      }
                                      

                                      and then

                                      void MainWindow::readPendingDatagrams()
                                      {
                                          while(mSocket->hasPendingDatagrams())
                                          {
                                              QByteArray datagram1;
                                              datagram1.resize(mSocket->pendingDatagramSize());
                                              mSocket->readDatagram(datagram1.data(),datagram1.size() );
                                              mPayload.append(datagram1.toHex());
                                          }
                                      }
                                      

                                      And this works fine.

                                      S Offline
                                      S Offline
                                      swansorter
                                      wrote on 10 Sept 2020, 06:29 last edited by
                                      #18

                                      @KroMignon
                                      void MainWindow::on_pushButton_2_pressed()
                                      {
                                      //if iuse class member or global variable;
                                      QString test= mPayLoad//class member;
                                      int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
                                      QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());

                                      for (int packet = 0; packet < cmd.length(); packet++)
                                      {
                                      //in this loop am getting segmentation fault*///
                                      Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;

                                         bufpo0 = bufpo0 + 4;
                                         bufpo1 = bufpo1 + 4;
                                         bufpo2 = bufpo2 + 4;
                                         bufpo3 = bufpo3 + 4;
                                      

                                      }

                                      S 1 Reply Last reply 10 Sept 2020, 06:30
                                      0
                                      • S swansorter
                                        10 Sept 2020, 06:29

                                        @KroMignon
                                        void MainWindow::on_pushButton_2_pressed()
                                        {
                                        //if iuse class member or global variable;
                                        QString test= mPayLoad//class member;
                                        int bufpo0 = 0, bufpo1 = 1, bufpo2 = 2, bufpo3 = 3;
                                        QByteArray cmd= QByteArray::fromHex(test.replace("\r\n","").toLatin1());

                                        for (int packet = 0; packet < cmd.length(); packet++)
                                        {
                                        //in this loop am getting segmentation fault*///
                                        Auto_image_RGBdata[packet] = static_cast<quint8>(cmd.data()[bufpo0]) | static_cast<quint8>(cmd.data()[bufpo1]) << 8 | static_cast<quint8>(cmd.data()[bufpo2]) << 16 | static_cast<quint8>(cmd.data()[bufpo3])<< 24;

                                           bufpo0 = bufpo0 + 4;
                                           bufpo1 = bufpo1 + 4;
                                           bufpo2 = bufpo2 + 4;
                                           bufpo3 = bufpo3 + 4;
                                        

                                        }

                                        S Offline
                                        S Offline
                                        swansorter
                                        wrote on 10 Sept 2020, 06:30 last edited by
                                        #19

                                        @swansorter in the above code i am getting segmentation fault

                                        K 1 Reply Last reply 10 Sept 2020, 06:56
                                        0
                                        • S swansorter
                                          10 Sept 2020, 06:30

                                          @swansorter in the above code i am getting segmentation fault

                                          K Offline
                                          K Offline
                                          KroMignon
                                          wrote on 10 Sept 2020, 06:56 last edited by
                                          #20

                                          @swansorter said in Receive data with UDP protocol:

                                          in the above code i am getting segmentation fault

                                          First, if you are expecting QByteArray, then store it as QByteArray in the readPendingDatagrams() slot, so don't have to convert from QByteArray to hexstring and back:

                                          void MainWindow::readPendingDatagrams()
                                          {
                                              while(mSocket->hasPendingDatagrams())
                                              {
                                                  QByteArray datagram1;
                                                  datagram1.resize(mSocket->pendingDatagramSize());
                                                  mSocket->readDatagram(datagram1.data(),datagram1.size() );
                                                  mPayload.append(datagram1);
                                              }
                                          }
                                          

                                          Then how did you declare Auto_image_RGBdata?

                                          It is an old maxim of mine that when you have excluded the impossible, whatever remains, however improbable, must be the truth. (Sherlock Holmes)

                                          S 1 Reply Last reply 10 Sept 2020, 07:06
                                          2

                                          1/25

                                          8 Sept 2020, 09:23

                                          • Login

                                          • Login or register to search.
                                          1 out of 25
                                          • First post
                                            1/25
                                            Last post
                                          0
                                          • Categories
                                          • Recent
                                          • Tags
                                          • Popular
                                          • Users
                                          • Groups
                                          • Search
                                          • Get Qt Extensions
                                          • Unsolved