I have an application that reads data from QUdp socket.The data comes as chunks with a header, after an header fixed size data and the remaining data.
header=50 bytes
fixed size=300
and the remainder is= <300
in this order.
My apllication runs as;
while(udpSocket->hasPendingDatagrams()) {
QByteArray datagram;
datagram.resize(udpSocket->pendingDatagramSize());
QHostAddress sender;
quint16 senderPort;
udpSocket->readDatagram(datagram.data(), datagram.size(),
&sender, &senderPort);
qout << "datagram received from " << sender.toString() << endl;
}
}
}
But i can not handle the last remainng bytes
Related
I have a microcontroller that sends stuff to an embedded Linux device over RS485 that shows up as a /dev/ttysomething. I use the QSerialPort class (from Qt 5.15.2) to read received data.
This basically works.
As a test, I send a block of 100 bytes, approximately once a second (in practice probably slightly slower than that). The value of the first byte of the first block is 0, then the value of each successive byte increases by 1. The receiving side expects that and checks whether something unexpected is received. It does this also once per second.
// In the header:
QTimer timer;
QSerialPort serialPort;
MyValues* myValues; // Contains some Q_PROPERTYs for displaying some values on the screen
// In the cpp:
void MyStuff::setup()
{
serialPort.setPortName("/dev/ttymxc2");
serialPort.setBaudRate(QSerialPort::Baud57600);
serialPort.setReadBufferSize(1);
if (!serialPort.open(QIODevice::ReadWrite))
{
qDebug() << "Cannot serialPort.open: " << serialPort.error();
return;
}
timer.setInterval(1000);
timer.setSingleShot(false);
QObject::connect(&timer, &QTimer::timeout, &timer, [=]()
{
// Display how many times the timer elapsed
myValues->setSendCount(myValues->sendCount() + 1);
{
auto info = qDebug().nospace();
info << "Available = " << serialPort.bytesAvailable() << ", ";
info << "Expected = ";
printHexByte(info, myValues->expectedValue());
}
QByteArray readData = serialPort.readAll();
if (serialPort.error() == QSerialPort::ReadError)
{
qDebug() << "serialPort.error is ReadError: " << serialPort.errorString();
}
else
{
auto line = qDebug().nospace();
line << "Read " << readData.length() << " bytes: ";
for (int i = 0; i < readData.length(); i++)
{
unsigned char actualValue = readData[i];
if (actualValue == myValues->expectedValue())
{
printHexByte(line, actualValue);
line << " ";
}
else
{
myValues->setMismatchCount(myValues->mismatchCount() + 1);
line << "\nMismatch: Expected = ";
printHexByte(line, myValues->expectedValue());
line << ", Actual = ";
printHexByte(line, actualValue);
line << "\n";
myValues->setExpectedValue(actualValue);
}
myValues->setExpectedValue(myValues->expectedValue() + 1);
}
}
});
timer.start();
}
What I would expect:
Assuming that the microcontroller sending the block and the reading happen sufficiently out-of-phase so that we don't read in the middle of a block.
Since the read buffer size is set to 1, I would expect that there is only ever one byte up for grabs, with the 99 other bytes of the block being discarded. So each time the timer elapses, one byte is available, serialPort.readAll() reads 1 byte and it's either the first or last byte of the block.
What actually happens:
Each time the timer elapses, one byte is available, serialPort.readAll() reads 1 byte, but its value is always the previous byte's value + 1, so no bytes are discarded.
So I was wondering: Where are the bytes buffered? And how do I prevent it?
Because if my program reading the data happens to go slower than the microcontroller sending it, I don't want everything to get out of sync and blow when the system eventually runs out of memory after running for hours, I'd rather detect dropped bytes through checksums and be notified of the problem immediately when it happens.
I want to connet with Qt on windows to my PIC32 UDP server. With a test program in C, I can connect and get the answer, but with Qt it is impossible. What am I doing wrong ?
As you can see I use an ACTIVE WAITING with the while, and my slot doesn't seems to be triggered. Maybe you can see my mistake here ? I hate active waiting....
Here is my code on Qt :
void MuTweezer::run()
{
QHostAddress sender;
quint16 senderPort;
QByteArray datagram;
qint64 pendingBytes;
int cpt = 0;
// Message to send
QByteArray message("Hello that's charly");
// m_imuRcvSocket.bind(10000); why is it for in a client side !?
// SEEMS to NOT BE TRIGGERED
connect(&m_imuRcvSocket, SIGNAL(readyRead()), this, SLOT(recu()));
while(m_isRunning && cpt++ < 10)
{
// send the initial message
qint64 bytesSent= m_imuRcvSocket.writeDatagram(message, QHostAddress("192.168.0.15"), 10000);
cout << "Bytes sent : " << bytesSent << endl;
// We wait the answer from the server
while(!m_imuRcvSocket.hasPendingDatagrams());
// If there is no datagram available, this function returns -1
if((pendingBytes = m_imuRcvSocket.pendingDatagramSize()) == -1)
continue;
datagram.resize(pendingBytes);
m_imuRcvSocket.readDatagram(datagram.data(), datagram.size(),
&sender, &senderPort);
cout << "================="
<< "\nMessage from <" << sender.toString().toStdString().substr(7) << "> on port " << senderPort
<< "\nString : " << datagram.data()
<< "\nSize: " << pendingBytes << " Bytes (characters)\n"
<< "=================" <<
endl;
}
}
Here is my code on the PIC32, as you can see, once I receive a message, I send the answer, it allows me to make a bidirectionnal communication :
if(!UDPIsOpened(mySocket)){
DBPRINTF("Socket CLOSED");
continue; // go back to loop beginning
}
DBPRINTF("Socket OPEN");
if(!(lengthToGet = UDPIsGetReady(mySocket)))
continue;
// get the string
// UDPGetArray : returns the number of bytes successfully read from the UDP buffer.
if((lengthWeGot = UDPGetArray(message, lengthToGet)))
UDPDiscard(); // Discards any remaining RX data from a UDP socket.
/* Modifie it and send it back */
if(UDPIsPutReady(mySocket)){
message[20]= 'Z';
message[21]= 'i';
message[22]= 'b';
message[23]= 'o';
UDPPutArray(message, lengthWeGot);
UDPFlush();
}
Any idea ?
Try to use waitForBytesWritten and waitForReadyRead:
// to receive datagrams, the socket needs to be bound to an address and port
m_imuRcvSocket.bind();
// send the initial message
QByteArray message("Hi it's Charly");
qint64 bytesSent= m_imuRcvSocket.writeDatagram(message,
QHostAddress("200.0.0.3"),
10000);
bool datagramWritten = m_imuRcvSocket.waitForBytesWritten();
// add code to check datagramWritten
datagram.resize(50); // random size for testing
bool datagramReady = m_imuRcvSocket.waitForReadyRead() && m_imuRcvSocket.hasPendingDatagrams();
// add code to check datagramReady
m_imuRcvSocket.readDatagram(datagram.data(),
datagram.size(),
&sender,
&senderPort);
cout << "================="
<< "\nMessage from <" << sender << "> on port " << senderPort
<< "\nString : " << datagram
<< "\nSize: " << pendingBytes << " Bytes (characters)\n"
<< "=================" <<
endl;
A better alternative would be to use signals and slots as described in the documentation of QUdpSocket
if you plan to use the microprocessor as a client with UDP you need the MAC address of the destination machine otherwise it will not work. This one took me 4 hours to figure out.
I have an issue when I receive data from a UDP client. The code that I used is:
MyUDP::MyUDP(QObject *parent) :
QObject(parent)
{
socket = new QUdpSocket(this);
socket->bind(QHostAddress("192.168.1.10"),2000);
connect(socket, SIGNAL(readyRead()), this, SLOT(readyRead()));
qDebug() << "Socket establert";
}
void MyUDP::HelloUDP()
{
QByteArray Data;
Data.append("R");
socket->writeDatagram(Data, QHostAddress("192.168.1.110"), 5001);
qDebug() << "Enviat datagrama";
}
void MyUDP::readyRead()
{
QByteArray buffer;
buffer.resize(socket->pendingDatagramSize());
QHostAddress sender;
quint16 senderPort;
socket->readDatagram(buffer.data(), buffer.size(), &sender, &senderPort);
qDebug() << "Message from: " << sender.toString();
qDebug() << "Message port: " << senderPort;
qDebug() << "Message: " << buffer;
qDebug() << "Size: " << buffer.size();
qDebug() << "Pending datagrams: " << socket->hasPendingDatagrams();
QString str(buffer);
QString res = str.toAscii().toHex(); qDebug() << res;
}
The problem is that in Wireshark I receive this data (all the data):
Internet Protocol Version 4, Src: 192.168.1.110, Dst: 192.168.1.10
User Datagram Protocol, Src Port: 5001, Dst Port: 2000
Data (20 bytes)
Data: 58bf80000059bf800000410000000053bf800000
[Length: 20]
But at the console output of my application I receive this trunkated data:
Message from: "192.168.1.110"
Message port: 5001
Message: "X¿
Size: 20
Pending datagrams: false
"58bf80"
You can see that only the first part of data "58bf80" is received. It seems that the datagram no has any limitation, and the socket runs fine. I don't see what may be happening.
Thanks in advance.
The truncation probably happens in conversion from QByteArray to QString, the string getting truncated in null terminator (byte with value 0).
To correctly convert from QByteArray to hex encoded QString use toHex function, like on the following example:
QByteArray data; //The data you got!
QString str = QString(data.toHex()); //Perform the conversion to hex encoded and to string
I am trying to get my IP camera stream in my Qt Widget application. First, I connect to UDP port of IP camera. IP camera is streaming H.264 encoded video. After socket is bound, on each readyRead() signal, I am filling the buffer with received datagrams in order to get a full frame.
Variable initialization:
AVCodec *codec;
AVCodecContext *codecCtx;
AVFrame *frame;
AVPacket packet;
this->buffer.clear();
this->socket = new QUdpSocket(this);
QObject::connect(this->socket, &QUdpSocket::connected, this, &H264VideoStreamer::connected);
QObject::connect(this->socket, &QUdpSocket::disconnected, this, &H264VideoStreamer::disconnected);
QObject::connect(this->socket, &QUdpSocket::readyRead, this, &H264VideoStreamer::readyRead);
QObject::connect(this->socket, &QUdpSocket::hostFound, this, &H264VideoStreamer::hostFound);
QObject::connect(this->socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));
QObject::connect(this->socket, &QUdpSocket::stateChanged, this, &H264VideoStreamer::stateChanged);
avcodec_register_all();
codec = avcodec_find_decoder(AV_CODEC_ID_H264);
if (!codec){
qDebug() << "Codec not found";
return;
}
codecCtx = avcodec_alloc_context3(codec);
if (!codecCtx){
qDebug() << "Could not allocate video codec context";
return;
}
if (codec->capabilities & CODEC_CAP_TRUNCATED)
codecCtx->flags |= CODEC_FLAG_TRUNCATED;
codecCtx->flags2 |= CODEC_FLAG2_CHUNKS;
AVDictionary *dictionary = nullptr;
if (avcodec_open2(codecCtx, codec, &dictionary) < 0) {
qDebug() << "Could not open codec";
return;
}
Algorithm is as follows:
void H264VideoImageProvider::readyRead() {
QByteArray datagram;
datagram.resize(this->socket->pendingDatagramSize());
QHostAddress sender;
quint16 senderPort;
this->socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
QByteArray rtpHeader = datagram.left(12);
datagram.remove(0, 12);
int nal_unit_type = datagram[0] & 0x1F;
bool start = (datagram[1] & 0x80) != 0;
int seqNo = rtpHeader[3] & 0xFF;
qDebug() << "H264 video decoder::readyRead()"
<< "from: " << sender.toString() << ":" << QString::number(senderPort)
<< "\n\tDatagram size: " << QString::number(datagram.size())
<< "\n\tH264 RTP header (hex): " << rtpHeader.toHex()
<< "\n\tH264 VIDEO data (hex): " << datagram.toHex();
qDebug() << "nal_unit_type = " << nal_unit_type << " - " << getNalUnitTypeStr(nal_unit_type);
if (start)
qDebug() << "START";
if (nal_unit_type == 7){
this->sps = datagram;
qDebug() << "Sequence parameter found = " << this->sps.toHex();
return;
} else if (nal_unit_type == 8){
this->pps = datagram;
qDebug() << "Picture parameter found = " << this->pps.toHex();
return;
}
//VIDEO_FRAME
if (start){
if (!this->buffer.isEmpty())
decodeBuf();
this->buffer.clear();
qDebug() << "Initializing new buffer...";
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x01));
this->buffer.append(this->sps);
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x01));
this->buffer.append(this->pps);
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x00));
this->buffer.append(char(0x01));
}
qDebug() << "Appending buffer data...";
this->buffer.append(datagram);
}
first 12 bytes of datagram is RTP header
everything else is VIDEO DATA
last 5 bits of first VIDEO DATA byte, says which NAL unit type it is. I always get one of the following 4 values (1 - coded non-IDR slice, 5 code IDR slice, 7 SPS, 8 PPS)
5th bit in 2nd VIDEO DATA byte says if this datagram is START data in frame
all VIDEO DATA is stored in buffer starting with START
once new frame arrives - START is set, it is decoded and new buffer is generated
frame for decoding is generated like this:
00 00 00 01
SPS
00 00 00 01
PPS
00 00 00 01
concatenated VIDEO DATA
decoding is made using avcodec_decode_video2() function from FFmpeg library
void H264VideoStreamer::decode() {
av_init_packet(&packet);
av_new_packet(&packet, this->buffer.size());
memcpy(packet.data, this->buffer.data_ptr(), this->buffer.size());
packet.size = this->buffer.size();
frame = av_frame_alloc();
if(!frame){
qDebug() << "Could not allocate video frame";
return;
}
int got_frame = 1;
int len = avcodec_decode_video2(codecCtx, frame, &got_frame, &packet);
if (len < 0){
qDebug() << "Error while encoding frame.";
return;
}
//if(got_frame > 0){ // got_frame is always 0
// qDebug() << "Data decoded: " << frame->data[0];
//}
char * frameData = (char *) frame->data[0];
QByteArray decodedFrame;
decodedFrame.setRawData(frameData, len);
qDebug() << "Data decoded: " << decodedFrame;
av_frame_unref(frame);
av_free_packet(&packet);
emit imageReceived(decodedFrame);
}
My idea is in UI thread which receives imageReceived signal, convert decodedFrame directly in QImage and refresh it once new frame is decoded and sent to UI.
Is this good approach for decoding H.264 stream? I am facing following problems:
avcodec_decode_video2() returns value that is the same like encoded buffer size. Is it possible that encoded and decoded date are always same size?
got_frame is always 0, so it means that I never really received full frame in the result. What can be the reason? Video frame incorrectly created? Or video frame incorrectly converted from QByteArray to AVframe?
How can I convert decoded AVframe back to QByteArray, and can it just be simply converted to QImage?
The whole process of manually rendering the frames can be left to another library. If the only purpose is a Qt GUI with live feed from the IP camera you can use libvlc library. You can find an example here: https://wiki.videolan.org/LibVLC_SampleCode_Qt
I am trying to send out a Proper mDNS response packet using QUdpSocket. The trouble I am having is creating the packet correctly. Could someone please show me the proper way to put together the packet.
So far this has not worked:
QByteArray datagram;
QDataStream out(&datagram, QIODevice::WriteOnly);
out << 0x8400; //set standard query
out << 0; //Reply code: no error;
out << 0; //Questions; 0
out << 0; //Answers; 0
out << 1; //Authoritive answers: 0
out << 0; //Additional RR;
QByteArray name("_home-sharing._tcp.local");
out << name;
out << 0x000c; //PTR
out << 1;//Class: IN
out << 1;//Cache Flush
out << 0; //Time to Live: 0;
Then i send the datagram, any help would be appreciated.
Thanks
QDataStream encodes into a special Qt format, it doesn't format into 'raw' binary.
You will need to serialise the data yourself. I would recommend just appending into the QByteArray. For example to serialize an uint16_t in network byte order you could use a function like this:
void appendUint16NBO(QByteArray& ba, uint16_t i)
{
ba.append(char((i >> 8) & 0xFF));
ba.append(char(i & 0xFF));
}
You would use the function as follows:
QByteArray datagram;
appendUint16NBO(datagram, 0x0000);
appendUint16NBO(datagram, 0x8400);
The QByteArray would then contain: 00 00 84 00.