[FK]天空端和地面端的摄像头发送接收程序-1

———————-.pro—————————–
QT += core gui

QT += core gui widgets # 确保 widgets 模块被包含

CONFIG += link_pkgconfig
PKGCONFIG += opencv4

QT += multimedia multimediawidgets

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
CameraWorker.cpp \
main.cpp \
mainwindow.cpp \
picDecode.c \
tcpsend.cpp \
udpsendthread.cpp

HEADERS += \
CameraWorker.h \
includes.h \
mainwindow.h \
picDecode.h \
tcpsend.h \
udpsendthread.h

FORMS += \
mainwindow.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

————–CameraWorker.h——————————

#ifndef CAMERAWORKER_H
#define CAMERAWORKER_H

#include
#include
#include
#include
#include

class CameraWorker : public QObject {
Q_OBJECT

public:
CameraWorker(QObject *parent = nullptr);
~CameraWorker();
void startCamera(int deviceIndex);
void stopCamera();

signals:
void frameCompress(const QByteArray &frameCompressData);

private:
cv::VideoCapture capture;
QMutex mutex;
bool isRunning;
void process();
void compressImageToMemory(const QImage &image);

};

#endif // CAMERAWORKER_H
—————————–includes.h——————————
#ifndef INCLUDES_H
#define INCLUDES_H

#define BASEPORT

#ifdef SKYPORT
#define LOCAL_IP “192.168.0.108”
#define LOCAL_PORT 12345
#define TARGET_IP “192.168.0.107”
#define TARGET_PORT 12000
#endif

#ifdef BASEPORT
#define LOCAL_IP “192.168.0.107”
#define LOCAL_PORT 12000
#define TARGET_IP “192.168.0.108”
#define TARGET_PORT 12345
#endif

#endif // INCLUDES_H

———————mainwindow.h—————————————

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include
#include
#include “CameraWorker.h” // 添加这一行以包含 CameraWorker
#include

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow {
Q_OBJECT

public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();

private slots:
void updateCameraFrame(const QImage &image);

void debugslot(const QByteArray &data);

private:
Ui::MainWindow *ui;
CameraWorker *cameraWorker; // 确保这个声明是正确的
QThread *cameraThread;
void bindThreadToCPU3(QThread *thread);
};

#endif // MAINWINDOW_H

—————————tcpsend.h————实际没用上—————
#ifndef TCPSEND_H
#define TCPSEND_H

#include
#include
#include
#include

class TcpSend : public QThread
{
Q_OBJECT

public:
explicit TcpSend(QObject *parent = nullptr);
~TcpSend();

void setTargetIp(const QString &ip);
void setTargetPort(quint16 port);

signals:
void dataReceived(const QByteArray &data);

protected:
void run() override;

private:
QTcpSocket *tcpSocket;
QString targetIp;
quint16 targetPort;

public slots:
void sendData(); // 实现发送功能
};

#endif // TCPSEND_H

——————————udpsendthread.h———————-
// udpsendthread.h
#ifndef UDPSENDTHREAD_H
#define UDPSENDTHREAD_H

#include
#include
#include

class UdpSendThread : public QObject
{
Q_OBJECT

public:
unsigned int times_rcv = 0;
int flag_rcv = 0;
int udpbagflag;
unsigned int datasize_max;
int connect_flag =0;
QByteArray picData;
public:
explicit UdpSendThread(QObject *parent = nullptr);
~UdpSendThread();

public slots:
void process(); // 模拟数据接收并触发dataReceived信号
void sendData(const QByteArray &data); // 实现UDP发送功能

void dataReceived(); // 当接收到数据时发出此信号

signals:

void frameCaptured(const QImage &image);

private:
QUdpSocket* udpSocket;
QString targetIP;
quint16 targetPort;
QImage decompressImageFromMemory( QByteArray &compressedData);

signals:
void dataRec(const QByteArray &data);

public slots:
void processData();
};

#endif // UDPSENDTHREAD_H

———————————–CameraWorker.cpp————————-

#include “CameraWorker.h”
#include // 包含 QDebug 以使用 qDebug()
#include
#include
#include
#include
#include “includes.h”

CameraWorker::CameraWorker(QObject *parent) : QObject(parent), isRunning(false) {}

CameraWorker::~CameraWorker() {
stopCamera();
}

void CameraWorker::startCamera(int deviceIndex) {
if (capture.isOpened()) return;

capture.open(deviceIndex);
if (!capture.isOpened()) {
qDebug() << "无法打开摄像头"; // 这里可以正常使用 qDebug() return; } capture.set(cv::CAP_PROP_FRAME_WIDTH, 640); // 设置宽度 capture.set(cv::CAP_PROP_FRAME_HEIGHT, 480); // 设置高度 capture.set(cv::CAP_PROP_FPS, 25); // 设置帧率 capture.set(cv::CAP_PROP_EXPOSURE, -4); // 设置曝光（根据需要调整） capture.set(cv::CAP_PROP_GAIN, 0); // 设置增益（根据需要调整） QThread::msleep(100); // 暂停以让设置生效 isRunning = true; QThread *thread = QThread::create([this]() { process(); }); connect(thread, &QThread::finished, this, &CameraWorker::deleteLater); thread->start();
}

void CameraWorker::stopCamera() {
QMutexLocker locker(&mutex);
isRunning = false;
capture.release();
}

void CameraWorker::process() {

#ifdef SKYPORT
while (true) {
{
QMutexLocker locker(&mutex);
if (!isRunning) break;
}

cv::Mat frame;
capture >> frame;
if (frame.empty()) continue;

cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
QImage image(frame.data, frame.cols, frame.rows, frame.step[0], QImage::Format_RGB888);

size_t memory_usage_qimage = image.width() * image.height() * image.depth() / 8;
// qDebug() << "QImage memory usage: " << memory_usage_qimage / 1024.0 / 1024.0 << " MB"; compressImageToMemory(image); //emit frameCaptured(image); QThread::msleep(50); // 限制帧率 } #endif } void CameraWorker::compressImageToMemory(const QImage &image) { // 创建一个 QBuffer 对象，它将充当内存缓冲区 QBuffer buffer; buffer.open(QIODevice::WriteOnly); // 创建 QImageWriter 对象，用于将图像压缩并写入内存缓存 QImageWriter writer(&buffer, "JPEG"); // 使用 JPEG 格式进行压缩，可以选择其他格式 // 设置压缩质量（如果适用） writer.setQuality(80); // 设定压缩质量，范围是 0-100 // 将 QImage 压缩并写入缓存 if (writer.write(image)) { // 压缩成功后，获取压缩后的数据大小 size_t compressedSize = buffer.size(); //qDebug() << "Compressed image size: " << compressedSize / 1024.0 / 1024.0 << " MB"; // 你可以从缓存中获取压缩后的数据 QByteArray compressedData = buffer.data(); // 例如，可以将数据保存到文件，或者发送到网络 emit frameCompress(compressedData); } else { qDebug() << "Image compression failed!"; } } ----------------------------------main.cpp------------------------ #include "mainwindow.h" #include
#include

int main(int argc, char *argv[]) {
QApplication a(argc, argv);
MainWindow w;
w.show();

int cpu = sched_getcpu();
qDebug() << "Running on CPU: " << cpu ; return a.exec(); } --------------------------------CameraWorker.cpp------------------- #include "CameraWorker.h" #include // 包含 QDebug 以使用 qDebug()
#include
#include
#include
#include
#include “includes.h”

CameraWorker::CameraWorker(QObject *parent) : QObject(parent), isRunning(false) {}

CameraWorker::~CameraWorker() {
stopCamera();
}

void CameraWorker::startCamera(int deviceIndex) {
if (capture.isOpened()) return;

capture.open(deviceIndex);
if (!capture.isOpened()) {
qDebug() << "无法打开摄像头"; // 这里可以正常使用 qDebug() return; } capture.set(cv::CAP_PROP_FRAME_WIDTH, 640); // 设置宽度 capture.set(cv::CAP_PROP_FRAME_HEIGHT, 480); // 设置高度 capture.set(cv::CAP_PROP_FPS, 25); // 设置帧率 capture.set(cv::CAP_PROP_EXPOSURE, -4); // 设置曝光（根据需要调整） capture.set(cv::CAP_PROP_GAIN, 0); // 设置增益（根据需要调整） QThread::msleep(100); // 暂停以让设置生效 isRunning = true; QThread *thread = QThread::create([this]() { process(); }); connect(thread, &QThread::finished, this, &CameraWorker::deleteLater); thread->start();
}

void CameraWorker::stopCamera() {
QMutexLocker locker(&mutex);
isRunning = false;
capture.release();
}

void CameraWorker::process() {

#ifdef SKYPORT
while (true) {
{
QMutexLocker locker(&mutex);
if (!isRunning) break;
}

cv::Mat frame;
capture >> frame;
if (frame.empty()) continue;

cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
QImage image(frame.data, frame.cols, frame.rows, frame.step[0], QImage::Format_RGB888);

size_t memory_usage_qimage = image.width() * image.height() * image.depth() / 8;
// qDebug() << "QImage memory usage: " << memory_usage_qimage / 1024.0 / 1024.0 << " MB"; compressImageToMemory(image); //emit frameCaptured(image); QThread::msleep(50); // 限制帧率 } #endif } void CameraWorker::compressImageToMemory(const QImage &image) { // 创建一个 QBuffer 对象，它将充当内存缓冲区 QBuffer buffer; buffer.open(QIODevice::WriteOnly); // 创建 QImageWriter 对象，用于将图像压缩并写入内存缓存 QImageWriter writer(&buffer, "JPEG"); // 使用 JPEG 格式进行压缩，可以选择其他格式 // 设置压缩质量（如果适用） writer.setQuality(80); // 设定压缩质量，范围是 0-100 // 将 QImage 压缩并写入缓存 if (writer.write(image)) { // 压缩成功后，获取压缩后的数据大小 size_t compressedSize = buffer.size(); //qDebug() << "Compressed image size: " << compressedSize / 1024.0 / 1024.0 << " MB"; // 你可以从缓存中获取压缩后的数据 QByteArray compressedData = buffer.data(); // 例如，可以将数据保存到文件，或者发送到网络 emit frameCompress(compressedData); } else { qDebug() << "Image compression failed!"; } } -------------------mainwindow.cpp-------------------------------- #include "mainwindow.h" #include "ui_mainwindow.h" #include // 包含 QDebug 以使用 qDebug()
#include “udpsendthread.h”
#include “tcpsend.h”
#include
#include “UdpReceiver.h”
#include “includes.h”

MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent), ui(new Ui::MainWindow), cameraWorker(new CameraWorker)
{
ui->setupUi(this);

#ifdef SKYPORT
// 创建线程
cameraThread = new QThread;
cameraWorker->moveToThread(cameraThread);

connect(cameraThread, &QThread::started, [this]() {
cameraWorker->startCamera(0); // 打开默认摄像头
});
connect(cameraThread, &QThread::finished, cameraWorker, &CameraWorker::deleteLater);

bindThreadToCPU3(cameraThread);

cameraThread->start();
#endif
// 创建线程和数据发送对象
QThread* udpthread = new QThread();
UdpSendThread* udpSendThread = new UdpSendThread();

// 将 udpSendThread 移动到新线程
udpSendThread->moveToThread(udpthread);

// 使用lambda函数启动信号槽
QObject::connect(udpthread, &QThread::started, udpSendThread, &UdpSendThread::process);

// 绑定信号槽，当udpSendThread接收到数据后发送数据
//QObject::connect(udpSendThread, &UdpSendThread::dataReceived, udpSendThread, &UdpSendThread::sendData);

QObject::connect(udpSendThread, &UdpSendThread::frameCaptured, this, &MainWindow::updateCameraFrame);

QObject::connect(udpSendThread, &UdpSendThread::dataRec, [](const QByteArray &data) {
qDebug() << "Received data:" << data; }); bindThreadToCPU3(udpthread); // 启动线程 udpthread->start();

connect(cameraWorker, &CameraWorker::frameCompress, udpSendThread, &UdpSendThread::sendData);

}

MainWindow::~MainWindow() {
cameraThread->quit();
cameraThread->wait();
delete ui;
}

void MainWindow::updateCameraFrame(const QImage &image) {
ui->cameraLabel->setPixmap(QPixmap::fromImage(image)); // 假设你在 UI 中有一个 QLabel 名为 cameraLabel
}

void MainWindow::bindThreadToCPU3(QThread *thread) {
// 获取当前线程的原生线程句柄
pthread_t nativeThread = pthread_self(); // 使用 pthread_self() 获取当前线程的句柄

// 创建 CPU 亲和性掩码
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(3, &cpuset); // 绑定到 CPU3

// 设置线程 CPU 亲和性
if (pthread_setaffinity_np(nativeThread, sizeof(cpu_set_t), &cpuset) != 0) {
qDebug() << "无法设置线程的 CPU 亲和性"; } else { qDebug() << "线程成功绑定到 CPU3"; } } void MainWindow::debugslot(const QByteArray &data) { qDebug()<<"hello"; } --------------------------------tcpsend.cpp------------------------------------ #include "tcpsend.h" #include
#include
#include

TcpSend::TcpSend(QObject *parent) : QThread(parent), targetPort(0), tcpSocket(nullptr) {
tcpSocket = new QTcpSocket(this);
}

TcpSend::~TcpSend() {
if (tcpSocket->isOpen()) {
tcpSocket->close();
}
}

void TcpSend::setTargetIp(const QString &ip) {
targetIp = ip;
}

void TcpSend::setTargetPort(quint16 port) {
targetPort = port;
}

void TcpSend::run() {
// Bind thread to CPU3 (core 3)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(3, &cpuset);
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);

// Connect to TCP server
tcpSocket->connectToHost(QHostAddress(targetIp), targetPort);
if (!tcpSocket->waitForConnected(3000)) {
qDebug() << "Error: Unable to connect to server!"; return; } /* connect(this, &TcpSend::dataReceived, [this](const QByteArray &data) { if (tcpSocket->isOpen()) {
tcpSocket->write(data);
tcpSocket->flush();
qDebug() << "Data sent: " << data; } }); */ exec(); // Start the event loop for the thread } void TcpSend::sendData() { QByteArray data = "Hello from tcpsend"; // 要发送的数据 if (tcpSocket->isOpen()) {
tcpSocket->write(data);
tcpSocket->flush();
qDebug() << "tcp Data sent: " << data; } int cpu = sched_getcpu(); qDebug() << "Running on CPU: " << cpu ; } --------------------------------udpsendthread.cpp------------------------ // udpsendthread.cpp #include "udpsendthread.h" #include
#include
#include
#include
#include
#include “includes.h”
#include
#include
#include
#include

UdpSendThread::UdpSendThread(QObject *parent) : QObject(parent),
udpSocket(new QUdpSocket(this))
{
if (!udpSocket->bind(QHostAddress(LOCAL_IP), LOCAL_PORT))
{
qDebug() << "Bind failed!"; } else { qDebug() << "Bind successful!"; } qDebug()<<"start startReceiving"; connect(udpSocket, &QUdpSocket::readyRead, this, &UdpSendThread::processData); } UdpSendThread::~UdpSendThread() { udpSocket->close();
delete udpSocket;
}

void UdpSendThread::process()
{
#ifdef BASEPORT
// 模拟数据接收，可以使用 QTimer 定时发出 dataReceived 信号
QTimer* timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &UdpSendThread::dataReceived);
timer->start(2); // 每5ms触发一次 dataReceived 信号
#endif
}

void UdpSendThread::sendData(const QByteArray & data)
{
//QByteArray datas = “Hello from udpsend”; // 要发送的数据
//udpSocket->writeDatagram(data, QHostAddress(targetIP), targetPort);
//qDebug() << "Data sent to" << targetIP << ":" << targetPort; //int cpu = sched_getcpu(); //qDebug() << "Running on CPU: " << cpu ; const int maxPacketSize = 65500; // UDP 单个数据包的最大数据量 int dataSize = data.size(); int offset = 0; if (datasize_max < dataSize) { datasize_max = dataSize; qDebug()<< "mx = " <writeDatagram(packet.mid(bytesSent), QHostAddress(TARGET_IP), TARGET_PORT);
if (result == -1) {
qDebug() << "Failed to send data:" << udpSocket->errorString();
QThread::msleep(10); // 短暂等待后再重试，避免过多的 CPU 占用
continue;
}
bytesSent += result;
}

offset += packetSize; // 更新偏移量
QThread::msleep(10); // 短暂等待后再重试，避免过多的 CPU 占用
/*
int packetSize = qMin(maxPacketSize, dataSize – offset); // 每次发送的字节数
QByteArray packet = data.mid(offset, packetSize); // 获取分包数据

qint64 bytesSent = udpSocket->writeDatagram(packet, QHostAddress(TARGET_IP), TARGET_PORT);
offset += packetSize;

if (udpSocket->waitForBytesWritten(3000)) {
;
} else {
qDebug() << "Timeout or error while writing data."; } //QThread::msleep(2); // 限制帧率 */ } auto end = std::chrono::high_resolution_clock::now(); // 计算时间差 auto duration = std::chrono::duration_cast(end – start).count();

//qDebug()<< "发送耗时: " << duration << "us" ; } void UdpSendThread::processData() { QImage rcvimage ; QNetworkDatagram datagram ; while (udpSocket->hasPendingDatagrams())
{
times_rcv = 0;
flag_rcv = 1;
datagram = udpSocket->receiveDatagram();
picData.append(datagram.data());
}

/*
QByteArray lastTwoBytes ;
if (datagram.data().size()>=2)
{
lastTwoBytes = datagram.data().right(2);
if ((lastTwoBytes[0]==0xFF)&&(lastTwoBytes[1]==0xD9))
{
udpbagflag = 1;
}
}

if (udpbagflag!=0)
{
rcvimage = decompressImageFromMemory(picData);
emit frameCaptured(rcvimage);
picData.clear();
udpbagflag = 0;

}
*/
//int cpu = sched_getcpu();
//qDebug() << "Running on CPU: " << cpu ; } QImage UdpSendThread::decompressImageFromMemory(QByteArray &compressedData) { int i = 0; QBuffer buffer(&compressedData); buffer.open(QIODevice::ReadOnly); // 打开为只读模式 // 使用 QImageReader 从 QBuffer 中读取压缩的图像 QImageReader reader(&buffer); QImage image = reader.read(); if (image.isNull()) { qDebug() << "Failed to decompress the image."; } return image; } void UdpSendThread::dataReceived() { QImage rcvimage ; if (times_rcv < 60000) { times_rcv++; } if (times_rcv < 10) { return; } if (flag_rcv ==0) { return; } flag_rcv = 0; rcvimage = decompressImageFromMemory(picData); emit frameCaptured(rcvimage); picData.clear(); }