1、添加配置文件控制推流参数；

2、解决遥控器解码时帧序混乱的问题（gop_size = 1）；
3、完善代码；

CMakeLists.txt

@@ -23,6 +23,9 @@ find_package(OpenCV 4.2.0 REQUIRED)
 include_directories(/usr/local/include/opencv4/)
 link_directories(/usr/local/lib)
 
+include_directories(/home/300tc/library/ffmpeg_build/include)
+link_directories(/home/300tc/library/ffmpeg_build/lib)
+
 add_executable(${CMAKE_PROJECT_NAME}
         Source_Files/fileoperation.cpp
         Header_Files/fileoperation.h
@@ -53,4 +56,8 @@ target_link_libraries(${CMAKE_PROJECT_NAME}
         irisXimeaImager
         libconfig.so
         libconfig++.so
-        ${OpenCV_LIBS})
+        ${OpenCV_LIBS}
+        avformat
+        avcodec
+        swscale
+        avutil)

Header_Files/MemoryPool.h

@@ -26,7 +26,7 @@
 #include <climits>
 #include <cstddef>
 
-template <typename T, size_t BlockSize = 16368000>
+template <typename T, size_t BlockSize = 409200000>
 class MemoryPool
 {
   public:

Header_Files/configfile.h

@@ -34,9 +34,16 @@ public:
     bool getspatialBin(int &spatialBin);
     bool getEffectiveWindow(int &width, int &offsetx, int &height, int &offsety);
     bool getEffectiveWindowRoi(int &width, int &offsetx);
+    bool getWindowOffsety_HeightOfSpectral(int &offsety, int &height, string spectralBinString);//spectralBinString = "bin1"或者”bin2“
     bool getGainOffset(float &gain, float &offset);
+    bool getGainOffsetOfSpectralBin1(float &gain, float &offset);
     bool getSN(QString &SN);
 
+    bool getBufferPolicy(int &bufferPolicy);
+    bool getAcqBufferSize(int &acqBufferSize);
+
+    bool getPushFlowParam(int &flowSwitch, int &rgbHeight, int &framerateVideo);
+
     bool createConfigFile();
     bool updateConfigFile();
 
@@ -44,4 +51,55 @@ private:
     string m_configfilePath;
     Config cfg;
 };
+
+class ParameterConfigfile
+{
+public:
+    ParameterConfigfile();
+    void setConfigfilePath(string configfilePath);
+    bool isConfigfileExist();
+    bool parseConfigfile();
+
+    bool getFrameRate(int &frameRate);
+    bool setFrameRate(int frameRate);
+
+    bool getExposeTime(float &exposeTime);
+    bool setExposeTime(float exposeTime);
+
+    bool createConfigFile();
+//    bool updateConfigFile();
+    bool writeConfig2File();
+
+    string m_configfilePath;
+    Config cfg;
+private:
+};
+
+class StateOf300tcConfigfile:public ParameterConfigfile
+{
+public:
+    StateOf300tcConfigfile();
+
+    bool getSwitchState(bool &switchState);
+    bool setSwitchState(bool switchState);
+
+    bool getSbgState(int &sbgState);
+    bool setSbgState(int sbgState);
+
+    bool getSbgSolutionMode(int &sbgSolutionMode);
+    bool setSbgSolutionMode(int sbgSolutionMode);
+
+    bool getXimeaState(int &ximeaState);
+    bool setXimeaState(int ximeaState);
+
+    bool getExposeMaxValueOfOneFrame(int &exposeMaxValueOfOneFrame);
+    bool setExposeMaxValueOfOneFrame(int exposeMaxValueOfOneFrame);
+
+    bool createConfigFile();
+
+private:
+    bool getIntValue(int &value, string field);
+    bool setIntValue(int value, string field);
+
+};
 #endif //XIMEAIMAGERECORDER_CONFIGFILE_H

Header_Files/rgbImage.h

@@ -11,6 +11,18 @@
 #include <QObject>
 #include <QImage>
 #include <opencv2/opencv.hpp>//包含了所有东西，编译很慢
+#include "opencv2/imgproc/types_c.h"
+
+extern "C"
+{
+    #include <libavcodec/avcodec.h>
+    #include <libavutil/opt.h>
+    #include "libavutil/pixfmt.h"
+    #include "libswscale/swscale.h"
+    #include <libavutil/imgutils.h>
+    #include <libavutil/avutil.h>
+    #include "libavdevice/avdevice.h"
+}
 
 using namespace cv;
 class rgbImage :public QObject
@@ -21,38 +33,33 @@ public:
     rgbImage(QWidget* pParent = NULL);
     ~rgbImage();
 
-    void SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNumber);
+    void SetRgbImageWidthAndHeight(int BandCount, int Width, int height);
+    void SetRgbBandNumber(int redBandNumber, int greenBandNumber, int blueBandNumber);
     void FillRgbImage(unsigned short *datacube);
     void FillFocusGrayImage(unsigned short *datacube);
     void FillFocusGrayQImage(unsigned short * datacube);
 
     void FillOnerowofRgbImage(cv::Mat * matRgbImage, int rowNumber, unsigned short *datacube);
+    QImage Mat2QImage(cv::Mat cvImg);//https://www.cnblogs.com/annt/p/ant003.html
 
     QImage *m_QRgbImage;
     cv::Mat *m_matRgbImage;
+    QImage m_Qphoto;
 
     QImage *m_qimageFocusGrayImage;
     cv::Mat *m_matFocusGrayImage;//用于调焦时，显示一帧的灰度图
     //cv::Mat m_matFocusGrayImage;//用于调焦时，显示一帧的灰度图
 
-
     CvVideoWriter *m_frame_writer;
     VideoWriter m_VideoWriter;
 //    VideoWriter m_video("appsrc ! autovideoconvert ! filesink location=/media/nvme/delete/live.avi", CV_FOURCC('M', 'J', 'P', 'G'), 25.0, Size(640, 480));
 //    VideoWriter video("test.avi", CV_FOURCC('M', 'J', 'P', 'G'), 25.0, Size(640, 480));//
 
-
-
-
-
     //控制该填充rgb图像第几帧（行）数据
     //以下两种情况需要重置为0：1）调用函数SetRgbImageWidthAndHeight；2）每次开始填充数据前
     int m_iFrameCounter;
-
-
     int m_iFramerate;//
 
-
 protected:
 
 private:
@@ -61,15 +68,17 @@ private:
 
     int m_iFrameNumber;//
 
+    void initffmpeg();
+
+    int m_iRedBandNumber;
+    int m_iGreenBandNumber;
+    int m_iBlueBandNumber;
+
 public slots:
 
 signals :
     void sendstr(QString str);
     void sendstr1(QString str);
     void refreslabelimg(QImage* img1);
-
-
 };
-
-
 #endif //XIMEAAIRBORNESYSTEM_RGBIMAGE_H

Header_Files/udpserver.h

@@ -11,17 +11,43 @@
 #include <QObject>
 #include <QThread>
 #include <QDir>
+#include <QtSerialPort/QSerialPort>
+#include <QtSerialPort/QSerialPortInfo>
 
 #include "ximeaimager.h"
 #include "sbgrecorder.h"
 #include "fileoperation.h"
 
+#include "configfile.h"
+
 extern "C"
 {
 //    #include <sbgEComLib.h>
     #include <stdlib.h>
 }
 
+class Record300TcTemperature : public QObject
+{
+Q_OBJECT
+
+public:
+    Record300TcTemperature();
+
+    void stopRecordTemperature();
+
+private:
+    bool m_bIsRecord;
+
+    QSerialPort * m_serial;
+
+    float parseMessage(QByteArray * data);
+public slots:
+    void recordTemperature(QString filePath);
+
+signals:
+
+};
+
 class UdpServer:public QObject
 {
     Q_OBJECT
@@ -48,6 +74,11 @@ class UdpServer:public QObject
 
     void sender(int status);
 
+    QThread * m_recordTempThread;
+    Record300TcTemperature * m_300tcTemperature;
+
+    StateOf300tcConfigfile stateOf300tc;
+
 signals:
     void systemStart();
     void systemStop();
@@ -56,6 +87,7 @@ signals:
     void startDeleteFileSignal();
 
     void recordXimeaOnlySignal(double,QString);
+    void record300tcTemperatureSignal(QString);
 
 public slots:
     void onRecordFinished();
@@ -67,6 +99,7 @@ public slots:
 
     void sendXimeaImageStatus(int ximeaImageStatus);
     void sendXimeaAutoExposeMaxValueOfOneFrame(int autoExposeMaxValueOfOneFrame, double exposeTime);
+    void sendXimeaBinState(int spatialBin, int spectralBin);
     void sendXimeaImageFrameRate(double frameRate);
     void sendCopyFileStatus(int fileStatus);
 };

Header_Files/ximeaimager.h

@@ -25,6 +25,10 @@
 #include <fstream>
 #include <unistd.h>
 #include <exception>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <cmath>
+#include <vector>
 
 #include <QObject>
 #include <QDateTime>
@@ -40,9 +44,12 @@
 #include "MemoryPool.h"
 #include <queue>
 #include <QMutex>
+#include <QUdpSocket>
 
 #include "rgbImage.h"
 
+#define PUSH_FLOW_PORT 666
+
 
 
 //#ifdef WIN32
@@ -62,18 +69,19 @@ public:
     DataBuffer();
     ~DataBuffer();
 
-    unsigned short data[425600];//304*1400=425600，为了兼容所有设置spectral bin和spatial bin
+    unsigned short data[41040000];//1368*300*100=41040000，为了兼容所有设置spectral bin和spatial bin
 
 private:
 
 };
 
+class XimeaImager;
 class RecordXimeaTemperature : public QObject
 {
 Q_OBJECT
 
 public:
-    RecordXimeaTemperature(Iris::IrisXimeaImager * imager);
+    RecordXimeaTemperature(Iris::IrisXimeaImager * imager, XimeaImager * ximeaImager);
 
     void stopRecordTemperature();
 
@@ -81,6 +89,7 @@ private:
     Iris::IrisXimeaImager * m_imager;
 
     bool m_bIsRecord;
+    XimeaImager * m_ximeaImager;
 public slots:
     void recordTemperature(QString filePath);
 
@@ -98,18 +107,48 @@ Q_OBJECT
 
 public:
     WriteData2Disk();
-    void setParm(queue<DataBuffer *> * q, QString baseFileName, int frameSizeInByte, MemoryPool<DataBuffer> * pool, rgbImage * rgbImage);
+    void setParm(queue<DataBuffer *> * q, queue<int> * qFrameCounter, QString baseFileName, int frameSizeInByte, int number_WriteDisk, MemoryPool<DataBuffer> * pool, rgbImage * rgbImage);
 
 private:
     queue<DataBuffer *> * m_q;
+    queue<int> * m_qFrameCounter;
     QString m_QbaseFileName;
     int m_iFrameSizeInByte;
+    int m_iNumber_WriteDisk;
     MemoryPool<DataBuffer> * m_pool;
+    bool isExitWriteData2Disk;
 
     rgbImage * m_rgbImage;
 
 public slots:
     void write2Disk();
+    void exitWriteData2Disk();
+
+signals:
+};
+
+class PushFlow : public QObject
+{
+Q_OBJECT
+
+public:
+    PushFlow();
+    void setParm(rgbImage * img, int width, int height, int framerateVideo);
+    void exitPushFlow();
+    void setVedioFilePath(QString path);
+
+private:
+    QString m_QVedioFilePath;
+    bool isExitPushFlow;
+
+    rgbImage * m_rgbImage;
+
+    int m_iWidth;
+    int m_iHeight;
+    int m_iFramerateVideo;
+
+public slots:
+    void encodePushFlow();
 
 signals:
 };
@@ -124,7 +163,7 @@ public:
 
     void setFramerate(double framerate);
     double getFramerate();
-    double setExposureTime(float exposureTime);
+    double setExposureTime(float exposureTime_in_us);
     int wrapSetExposureTime(float exposureTime_in_us);
     double getExposureTime();
     double autoExposure();
@@ -137,8 +176,12 @@ public:
     int getWindowEndBand();
     double geWavelengthAtBand(int x);
 
+    static int findClosestIndex(const std::vector<double>& numbers, double target);
+    void getRgbBandNumber(int &redBandNumber, int &greenBandNumber, int &blueBandNumber);
+
     void stopRecord();
     int getFrameCounter();
+    void writeXiApiErrorCodes(QString filePath, int xiApiErrorCodes);
 
     int getMaxValueOfOneFrame(unsigned short * data, int numberOfPixel);
 
@@ -148,14 +191,22 @@ private:
     int m_iImagerState;
     int m_iImagerStateTemp;
 
+    int m_iOffsetyOfSpectralBin1, m_iOffsetyOfSpectralBin2;
+    int m_iHeightOfSpectralBin1, m_iHeightOfSpectralBin2;
+
     QThread * m_recordTempThread;
     RecordXimeaTemperature * m_ximeaTemperature;
 
     QThread * writeData2DiskThread;
     WriteData2Disk * writeData2Disk;
     queue<DataBuffer *> * q;
+    queue<int> * m_qFrameCounter;
     MemoryPool<DataBuffer> * m_pool;
 
+    QThread * m_pushFlowThread;
+    PushFlow * m_pushFlow;
+    int m_iFlowSwitch;
+
     QString m_baseFileName;
     QString m_ximeaTemperatureCSVPath;
 
@@ -170,26 +221,14 @@ private:
 
     void processXiApiErrorCodes(int xiApiErrorCodes);
 
-    inline double getSbgTime(double TimeDifferenceBetweensOSAndSbg)
+    inline double getSbgTime(XI_IMG * image, double timeDifferenceBetweenSbgAndXimea)
     {
-        struct timespec systemTime;
+        double ximeaTime = (double)image->tsSec + (double)image->tsUSec/1000000;
-        clock_gettime(CLOCK_REALTIME,&systemTime);
+        return ximeaTime + timeDifferenceBetweenSbgAndXimea;
-        tm systemTime_rili;
-        localtime_r(&systemTime.tv_sec, &systemTime_rili);
-
-        double secondSystem=(systemTime_rili.tm_mday-1)*24*60*60+systemTime_rili.tm_hour*60*60+systemTime_rili.tm_min*60+systemTime_rili.tm_sec;
-        double nanosecondSystem=secondSystem+static_cast<double>(systemTime.tv_nsec)/1000000000;
-
-
-//        printf("\n");
-//        printf("XimeaImager::getSbgTime------系统时间纳秒%d\n", systemTime.tv_nsec);
-//        printf("XimeaImager::getSbgTime------系统时间(未偏移)%f\n", nanosecondSystem);
-//        printf("XimeaImager::getSbgTime------系统时间(偏移)%f\n", nanosecondSystem-TimeDifferenceBetweensOSAndSbg);
-
-        return nanosecondSystem-TimeDifferenceBetweensOSAndSbg;
     }
 
     Configfile m_configfile;
+    ParameterConfigfile m_parameterConfigfile;
 
 
 
@@ -197,6 +236,7 @@ public slots:
     void openImger();
     void closeImger();
 
+    double calculateTimeDifferenceBetweenSbgAndximea(XI_IMG * m_image, double timeDifferenceBetweenSbgAndOS);
     void startRecord(double TimeDifferenceBetweensOSAndSbg,QString baseFileName);
 
 signals:
@@ -205,8 +245,10 @@ signals:
 
     void recordXimeaTemperatureSignal(QString);
     void startWriteDiskSignal();
+    void startPushFlowSignal();
 
     void autoExposeMaxValueOfOneFrame(int, double);
     void frameRateSignal(double);
+    void binSignal(int, int);
 };
 #endif // XIMEAIMAGER_H

Source_Files/configfile.cpp

@@ -166,6 +166,86 @@ bool Configfile::getEffectiveWindowRoi(int &width, int &offsetx)
     return true;
 }
 
+bool Configfile::getPushFlowParam(int &flowSwitch, int &rgbHeight, int &framerateVideo)
+{
+    Setting& root = cfg.getRoot();
+
+    if (!root.exists("push_flow_param"))
+    {
+        // 配置项不存在，添加配置项
+        Setting & push_flow_param = root.add("push_flow_param", Setting::TypeGroup);
+
+        push_flow_param.add("flow_switch", Setting::TypeInt) = 0;
+        push_flow_param.add("rgb_height", Setting::TypeInt) = 720;
+        push_flow_param.add("framerate_video", Setting::TypeInt) = 5;
+
+        // 保存修改后的配置到文件
+        try
+        {
+            QList<QString> fileInfo = getFileInfo(QString::fromStdString(m_configfilePath));
+            bool ret = createDir(fileInfo[0]);
+
+            cfg.writeFile(m_configfilePath.c_str());
+            std::cout << "Config item 'push_flow_param' added." << std::endl;
+
+            flowSwitch = 0;
+            rgbHeight = 720;
+            framerateVideo = 5;
+
+            return true;
+        }
+        catch (const libconfig::FileIOException &fioex)
+        {
+            std::cerr << "I/O error while writing file." << std::endl;
+            return false;
+        }
+    }
+    else
+    {
+        try
+        {
+            const Setting &push_flow_param = root["push_flow_param"];
+
+            if(!(push_flow_param.lookupValue("rgb_height", rgbHeight)
+                 && push_flow_param.lookupValue("framerate_video", framerateVideo)
+                 && push_flow_param.lookupValue("flow_switch", flowSwitch)
+            ))
+            {
+                return false;
+            }
+        }
+        catch(const SettingNotFoundException &nfex)
+        {
+            // Ignore.
+            return false;
+        }
+
+        return true;
+    }
+}
+
+bool Configfile::getWindowOffsety_HeightOfSpectral(int &offsety, int &height, string spectralBinString)
+{
+    const Setting& root = cfg.getRoot();
+
+    try
+    {
+        const Setting &spectralArgument = root["effective_window"][spectralBinString]["spectral"];
+        if(!(spectralArgument.lookupValue("height", height)
+             && spectralArgument.lookupValue("offsety", offsety)))
+        {
+            return false;
+        }
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        // Ignore.
+        return false;
+    }
+
+    return true;
+}
+
 bool Configfile::getGainOffset(float &gain, float &offset)
 {
     const Setting& root = cfg.getRoot();
@@ -206,6 +286,35 @@ bool Configfile::getGainOffset(float &gain, float &offset)
     return true;
 }
 
+bool Configfile::getGainOffsetOfSpectralBin1(float &gain, float &offset)
+{
+    const Setting& root = cfg.getRoot();
+
+    try
+    {
+        const Setting &gainOffset = root["gainOffset"];
+        int count = gainOffset.getLength();
+
+        string spectralBinString = "spectralBin1";
+
+        const Setting &gainOffsetSetting = gainOffset[spectralBinString];
+        string name = gainOffsetSetting.getName();
+
+        if(!(gainOffsetSetting.lookupValue("gain", gain)
+             && gainOffsetSetting.lookupValue("offset", offset)))
+        {
+            return false;
+        }
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        // Ignore.
+        return false;
+    }
+
+    return true;
+}
+
 bool Configfile::getSN(QString &SN)
 {
     try
@@ -222,6 +331,50 @@ bool Configfile::getSN(QString &SN)
     }
 }
 
+bool Configfile::getBufferPolicy(int &bufferPolicy)
+{
+    const Setting& root = cfg.getRoot();
+    const Setting &ximeadll = root["ximeadll"];
+
+    try
+    {
+        if(!(ximeadll.lookupValue("buffer_policy", bufferPolicy)
+        ))
+        {
+            return false;
+        }
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'spectralBin' setting in configuration file." << endl;
+        return false;
+    }
+
+    return true;
+}
+
+bool Configfile::getAcqBufferSize(int &acqBufferSize)
+{
+    const Setting& root = cfg.getRoot();
+    const Setting &ximeadll = root["ximeadll"];
+
+    try
+    {
+        if(!(ximeadll.lookupValue("acq_buffer_size", acqBufferSize)
+        ))
+        {
+            return false;
+        }
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'spectralBin' setting in configuration file." << endl;
+        return false;
+    }
+
+    return true;
+}
+
 bool Configfile::createConfigFile()
 {
     using namespace std;
@@ -279,6 +432,11 @@ bool Configfile::createConfigFile()
     gainOffsetSpectralBin2.add("offset", Setting::TypeFloat) = -299.46126663407176;
 
 
+    Setting &ximeadll = root.add("ximeadll", Setting::TypeGroup);
+    ximeadll.add("buffer_policy", Setting::TypeInt) = 0;
+    ximeadll.add("acq_buffer_size", Setting::TypeInt) = 400;
+
+
     // Write out the new configuration.
     QString output_file = "/media/nvme/300TC/config/ximea.cfg";
     try
@@ -368,3 +526,295 @@ bool Configfile::updateConfigFile()
 
     return true;
 }
+
+ParameterConfigfile::ParameterConfigfile()
+{
+
+}
+
+void ParameterConfigfile::setConfigfilePath(string configfilePath)
+{
+    m_configfilePath = configfilePath;
+}
+
+bool ParameterConfigfile::isConfigfileExist()
+{
+    QFileInfo info(QString::fromStdString(m_configfilePath));
+
+    return info.exists();
+}
+
+bool ParameterConfigfile::parseConfigfile()
+{
+    // Read the file. If there is an error, report it and exit.
+    try
+    {
+        cfg.readFile(m_configfilePath);
+
+        return true;
+    }
+    catch(const FileIOException &fioex)
+    {
+        std::cerr << "I/O error while reading file." << std::endl;
+        return false;
+    }
+    catch(const ParseException &pex)
+    {
+        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+                  << " - " << pex.getError() << std::endl;
+        return false;
+    }
+}
+
+bool ParameterConfigfile::createConfigFile()
+{
+    using namespace std;
+    using namespace libconfig;
+
+    Config cfg;
+
+    Setting &root = cfg.getRoot();
+
+    // Add some settings to the configuration.
+//    Setting &SN = root.add("SN", Setting::TypeString) = "0098";
+//    Setting &spatialBin = root.add("spatialBin", Setting::TypeInt) = 2;
+//    Setting &SpectralBin = root.add("spectralBin", Setting::TypeInt) = 2;
+
+    Setting &ximeaParam = root.add("ximeaParam", Setting::TypeGroup);
+    ximeaParam.add("frameRate", Setting::TypeInt) = 100;
+    ximeaParam.add("exposeTime", Setting::TypeFloat) = 10.0;
+
+
+    // Write out the new configuration.
+    try
+    {
+        QList<QString> fileInfo = getFileInfo(QString::fromStdString(m_configfilePath));
+        bool ret = createDir(fileInfo[0]);
+
+        cfg.writeFile(m_configfilePath.c_str());
+        cerr << "New configuration successfully written to: " << m_configfilePath.c_str() << endl;
+
+    }
+    catch(const FileIOException &fioex)
+    {
+        cerr << "I/O error while writing configuration file: " << m_configfilePath.c_str() << endl;
+        return true;
+    }
+
+    return true;
+}
+
+bool ParameterConfigfile::getFrameRate(int &frameRate)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        const Setting &ximeaParam = root["ximeaParam"];
+        frameRate = ximeaParam.lookup("frameRate");
+
+//        std::cout << "ParameterConfigfile::getFrameRate："<< frameRate<<std::endl;
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'frameRate' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool ParameterConfigfile::setFrameRate(int frameRate)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        Setting &frameRate2 = root["ximeaParam"]["frameRate"];
+        frameRate2 = frameRate;
+
+        writeConfig2File();
+
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'frameRate' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool ParameterConfigfile::getExposeTime(float &exposeTime)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        const Setting &ximeaParam = root["ximeaParam"];
+        exposeTime = ximeaParam.lookup("exposeTime");
+
+//        std::cout << "ParameterConfigfile::getExposeTime"<< exposeTime<<std::endl;
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'exposeTime' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool ParameterConfigfile::setExposeTime(float exposeTime)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        Setting &frameRate2 = root["ximeaParam"]["exposeTime"];
+        frameRate2 = exposeTime;
+
+        writeConfig2File();
+
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'exposeTime' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool ParameterConfigfile::writeConfig2File()
+{
+    try
+    {
+        QList<QString> fileInfo = getFileInfo(QString::fromStdString(m_configfilePath));
+        bool ret = createDir(fileInfo[0]);
+
+        cfg.writeFile(m_configfilePath.c_str());
+//        cerr << "New configuration successfully written to: " << m_configfilePath.c_str() << endl;
+    }
+    catch(const FileIOException &fioex)
+    {
+        cerr << "I/O error while writing configuration file: " << m_configfilePath.c_str() << endl;
+        return false;
+    }
+    return true;
+}
+
+StateOf300tcConfigfile::StateOf300tcConfigfile()
+{
+}
+
+bool StateOf300tcConfigfile::getIntValue(int &value, string field)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        const Setting &ximeaParam = root["ximeaParam"];
+        value = ximeaParam.lookup(field);
+
+//        std::cout << "StateOf300tcConfigfile::getIntValue"<< value<<std::endl;
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool StateOf300tcConfigfile::setIntValue(int value, string field)
+{
+    const Setting& root = cfg.getRoot();
+    try
+    {
+        Setting &frameRate2 = root["ximeaParam"][field];
+        frameRate2 = value;
+
+        writeConfig2File();
+
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool StateOf300tcConfigfile::createConfigFile()
+{
+    using namespace std;
+    using namespace libconfig;
+
+    Config cfg;
+
+    Setting &root = cfg.getRoot();
+
+    // Add some settings to the configuration.
+//    Setting &SN = root.add("SN", Setting::TypeString) = "0098";
+//    Setting &spatialBin = root.add("spatialBin", Setting::TypeInt) = 2;
+//    Setting &SpectralBin = root.add("spectralBin", Setting::TypeInt) = 2;
+
+    Setting &ximeaParam = root.add("ximeaParam", Setting::TypeGroup);
+    ximeaParam.add("sbgState", Setting::TypeInt) = 0;
+    ximeaParam.add("sbgSolutionMode", Setting::TypeInt) = 0;
+    ximeaParam.add("ximeaState", Setting::TypeInt) = 100;
+    ximeaParam.add("frameRate", Setting::TypeInt) = 0;
+    ximeaParam.add("exposeTime", Setting::TypeFloat) = 0.0;
+    ximeaParam.add("exposeMaxValueOfOneFrame", Setting::TypeInt) = 0;
+
+
+    // Write out the new configuration.
+    try
+    {
+        QList<QString> fileInfo = getFileInfo(QString::fromStdString(m_configfilePath));
+        bool ret = createDir(fileInfo[0]);
+
+        cfg.writeFile(m_configfilePath.c_str());
+        cerr << "New configuration successfully written to: " << m_configfilePath.c_str() << endl;
+
+    }
+    catch(const FileIOException &fioex)
+    {
+        cerr << "I/O error while writing configuration file: " << m_configfilePath.c_str() << endl;
+        return true;
+    }
+
+    return true;
+}
+
+bool StateOf300tcConfigfile::getSbgState(int &sbgState)
+{
+    return getIntValue(sbgState,"sbgState");
+}
+
+bool StateOf300tcConfigfile::setSbgState(int sbgState)
+{
+    return setIntValue(sbgState,"sbgState");
+}
+
+bool StateOf300tcConfigfile::getSbgSolutionMode(int &sbgSolutionMode)
+{
+    return getIntValue(sbgSolutionMode,"sbgSolutionMode");
+}
+
+bool StateOf300tcConfigfile::setSbgSolutionMode(int sbgSolutionMode)
+{
+    return setIntValue(sbgSolutionMode,"sbgSolutionMode");
+}
+
+bool StateOf300tcConfigfile::getXimeaState(int &ximeaState)
+{
+    return getIntValue(ximeaState,"ximeaState");
+}
+
+bool StateOf300tcConfigfile::setXimeaState(int ximeaState)
+{
+    return setIntValue(ximeaState,"ximeaState");
+}
+
+bool StateOf300tcConfigfile::getExposeMaxValueOfOneFrame(int &exposeMaxValueOfOneFrame)
+{
+    return getIntValue(exposeMaxValueOfOneFrame,"exposeMaxValueOfOneFrame");
+}
+
+bool StateOf300tcConfigfile::setExposeMaxValueOfOneFrame(int exposeMaxValueOfOneFrame)
+{
+    return setIntValue(exposeMaxValueOfOneFrame,"exposeMaxValueOfOneFrame");
+}

Source_Files/main.cpp

@@ -3,6 +3,7 @@
 
 int main(int argc, char *argv[])
 {
+    std::cout<<"ximeaAirborneSystem 版本："<< "41." <<std::endl;
     QCoreApplication a(argc, argv);
 
     //UdpServer* x=new UdpServer();

Source_Files/rgbImage.cpp

@@ -4,7 +4,6 @@
 
 #include "../Header_Files/rgbImage.h"
 
-
 rgbImage::rgbImage(QWidget* pParent)
 {
     m_QRgbImage = nullptr;
@@ -12,8 +11,9 @@ rgbImage::rgbImage(QWidget* pParent)
     m_matFocusGrayImage = nullptr;
     m_qimageFocusGrayImage = nullptr;
 
-
+    m_iRedBandNumber = 0;
-
+    m_iGreenBandNumber = 0;
+    m_iBlueBandNumber = 0;
 }
 
 rgbImage::~rgbImage()
@@ -21,8 +21,18 @@ rgbImage::~rgbImage()
 
 }
 
+void rgbImage::SetRgbBandNumber(int redBandNumber, int greenBandNumber, int blueBandNumber)
+{
+    m_iRedBandNumber = redBandNumber;
+    m_iGreenBandNumber = greenBandNumber;
+    m_iBlueBandNumber = blueBandNumber;
 
-void rgbImage::SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNumber)
+//    std::cout<<"rgbImage::SetRgbBandNumber，红波段的波段号："<< redBandNumber <<std::endl;
+//    std::cout<<"rgbImage::SetRgbBandNumber，绿波段的波段号："<< greenBandNumber <<std::endl;
+//    std::cout<<"rgbImage::SetRgbBandNumber，蓝波段的波段号："<< blueBandNumber <<std::endl;
+}
+
+void rgbImage::SetRgbImageWidthAndHeight(int BandCount, int Width, int height)
 {
     using namespace cv;
 
@@ -30,19 +40,21 @@ void rgbImage::SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNum
     {
         delete m_QRgbImage;//有问题？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
     }
-    //m_QRgbImage = new QImage(Sample, FrameNumber, QImage::Format_RGB888);
+    //m_QRgbImage = new QImage(Width, height, QImage::Format_RGB888);
 
 
     if (m_matRgbImage != nullptr)
     {
         delete m_matRgbImage;
     }
-    m_matRgbImage = new Mat(FrameNumber, Sample, CV_8UC3, Scalar(0, 0, 0));
+    m_matRgbImage = new Mat(height, Width, CV_8UC3, Scalar(0, 0, 0));
 
-    int codec = VideoWriter::fourcc('M', 'P', '4', '2');  // select desired codec (must be available at runtime)
+//    int codec = VideoWriter::fourcc('H', '2', '6', '4');  // select desired codec (must be available at runtime)
-    double fps = 20.0;                          // framerate of the created video stream
+//    double fps = 20.0;// framerate of the created video stream
-    std::string filename = "appsrc ! autovideoconvert ! filesink location=/media/nvme/delete/live.avi";//https://blog.csdn.net/ancientapesman/article/details/117324638
+//    std::string filename = "appsrc ! autovideoconvert ! filesink location=/media/nvme/live.mp4";//https://blog.csdn.net/ancientapesman/article/details/117324638
-    m_VideoWriter.open(filename, codec, fps, m_matRgbImage->size(), true);
+////    std::string filename = "/media/nvme/live.mp4";
+//    auto ddddd=m_matRgbImage->size();
+//    m_VideoWriter.open(filename, codec, fps, Size(20, 1368), true);
 
 //    VideoWriter video("test.avi", CV_FOURCC('M', 'J', 'P', 'G'), 25.0, Size(640, 480));
 
@@ -54,127 +66,169 @@ void rgbImage::SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNum
 
     if (m_qimageFocusGrayImage == nullptr)
     {
-        m_qimageFocusGrayImage = new QImage(Sample, BandCount, QImage::Format_RGB32);
+        m_qimageFocusGrayImage = new QImage(Width, BandCount, QImage::Format_RGB32);
     }
 
 
     if (m_matFocusGrayImage == nullptr)
     {
-        m_matFocusGrayImage = new Mat(BandCount, Sample, CV_16U, Scalar(0));
+        m_matFocusGrayImage = new Mat(BandCount, Width, CV_16U, Scalar(0));
 
-        //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Sample, CV_16U);
+        //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Width, CV_16U);
     }
 
-    //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Sample, CV_16U);
+    //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Width, CV_16U);
     //m_matFocusGrayImage = matAdjustPreview;
 
-
+    std::cout << "高光谱rgb图像设置高度：" << height << std::endl;
-
-
-
-
-
-
-    std::cout << "设置帧数：" << FrameNumber << std::endl;
 
     m_iFrameCounter = 0;//每次都重置为0
-    m_iSampleNumber = Sample;
+    m_iSampleNumber = Width;
     m_iBandNumber = BandCount;
-    m_iFrameNumber = FrameNumber;
+    m_iFrameNumber = height;
 
     //std::cout << "rgb影像内存地址为：" << m_QRgbImage << std::endl;
 }
 
 void rgbImage::FillOnerowofRgbImage(cv::Mat * matRgbImage, int rowNumber, unsigned short *datacube)
 {
+    //方式1：逐像素修改
+//    unsigned short r, g, b;
+//    for (int j = 0; j < m_iSampleNumber; j++)
+//    {
+//        //取值：一帧影像中，从左到右的rgb像元值
+//        r = *(datacube + m_iRedBandNumber * m_iSampleNumber + j)*255/4096;
+//        g = *(datacube + m_iGreenBandNumber * m_iSampleNumber + j)*255/4096;
+//        b = *(datacube + m_iBlueBandNumber * m_iSampleNumber + j)*255/4096;
+//
+////        r = *(datacube + m_iRedBandNumber * m_iSampleNumber + j);
+////        g = *(datacube + m_iGreenBandNumber * m_iSampleNumber + j);
+////        b = *(datacube + m_iBlueBandNumber * m_iSampleNumber + j);
+//
+//        //将像元值赋值到cv::Mat中，操作像元值：https://zhuanlan.zhihu.com/p/51842288
+//        //int dataType = m_matRgbImage->type();//当数据类型为CV_16UC3时，返回18
+//        //std::cout << "m_matRgbImage数据类型为：" << dataType << std::endl;
+//        if (matRgbImage->type() == CV_8UC3)
+//        {
+////            std::cout << "操作像素值！" << std::endl;
+//            matRgbImage->at<cv::Vec3b>(rowNumber, j)[2] = r;
+//            matRgbImage->at<cv::Vec3b>(rowNumber, j)[1] = g;
+//            matRgbImage->at<cv::Vec3b>(rowNumber, j)[0] = b;
+//
+////            QString savePath_cv = "/media/nvme/delete/" + QString::number(m_iFrameCounter) + "_cv.png";
+////            cv::imwrite(savePath_cv.toStdString(), *matRgbImage);
+//        }
+//
+//        int column = 800;
+//        if(j == column)
+//        {
+//            std::cout << "行：" << rowNumber << "提取：第 " << column << " 列的 r g b 分别为 " << r <<  " " << g <<  " " << b << std::endl;
+//            std::cout << "mat：第 " << column << " 列的 r g b 分别为 " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[2] <<  " " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[1] <<  " " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[0] << std::endl;
+//        }
+//    }
+
+    //方式2：通过指针操作，更快
     unsigned short r, g, b;
+    const int cols = matRgbImage->cols;
+    const int step = matRgbImage->channels();
+
+    unsigned char *p_row0_b = matRgbImage->ptr(rowNumber);
+    unsigned char *p_row0_g = matRgbImage->ptr(rowNumber) + 1;
+    unsigned char *p_row0_r = matRgbImage->ptr(rowNumber) + 2;
+
     for (int j = 0; j < m_iSampleNumber; j++)
     {
-        //取值：一帧影像中，从左到右的rgb像元值
+        //取值：一帧影像中，从左到右的rgb像元值，线性拉伸
-        r = *(datacube + 121 * m_iSampleNumber + j)*255/4096;
+        r = *(datacube + m_iRedBandNumber * m_iSampleNumber + j)*255/4096;
-        g = *(datacube + 79 * m_iSampleNumber + j)*255/4096;
+        g = *(datacube + m_iGreenBandNumber * m_iSampleNumber + j)*255/4096;
-        b = *(datacube + 40 * m_iSampleNumber + j)*255/4096;
+        b = *(datacube + m_iBlueBandNumber * m_iSampleNumber + j)*255/4096;
 
-        //将像元值赋值到cv::Mat中，操作像元值：https://zhuanlan.zhihu.com/p/51842288
+        *p_row0_b = b;
-        //int dataType = m_matRgbImage->type();//当数据类型为CV_16UC3时，返回18
+        *p_row0_g = g;
-        //std::cout << "m_matRgbImage数据类型为：" << dataType << std::endl;
+        *p_row0_r = r;
-        if (matRgbImage->type() == CV_16UC3)
+
-        {
+//        int column = 800;
-            //std::cout << "操作像素值！" << std::endl;
+//        if(j == column)
-            matRgbImage->at<cv::Vec3w>(rowNumber, j)[2] = r;
+//        {
-            matRgbImage->at<cv::Vec3w>(rowNumber, j)[1] = g;
+//            std::cout << "行：" << rowNumber << "提取：第 " << column << " 列的 r g b 分别为 " << r <<  " " << g <<  " " << b << std::endl;
-            matRgbImage->at<cv::Vec3w>(rowNumber, j)[0] = b;
+////            std::cout << "修改后" << rowNumber << "提取：第 " << column << " 列的 r g b 分别为 " << (unsigned short)*p_row0_r <<  " " << (unsigned short)*p_row0_g <<  " " << (unsigned short)*p_row0_b << std::endl;
-        }
+////            std::cout << "mat：第 " << column << " 列的 r g b 分别为 " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[2] <<  " " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[1] <<  " " << (unsigned short)matRgbImage->at<cv::Vec3b>(rowNumber, j)[0] << std::endl;
+//        }
+
+        p_row0_b += step;
+        p_row0_g += step;
+        p_row0_r += step;
     }
+
+    //方式3：通过内存拷贝快速提取rgb
+//    if (matRgbImage->isContinuous())// check mat is continuous or not
+//        matRgbImage->reshape(1, matRgbImage->rows * matRgbImage->cols).col(0).setTo(Scalar(value));
+//    else
+//    {
+//        for (int i = 0; i < matRgbImage->rows; i++)
+//            matRgbImage->row(i).reshape(1, matRgbImage->cols).col(0).setTo(Scalar(value));
+//    }
+}
+
+QImage rgbImage::Mat2QImage(cv::Mat cvImg)//https://www.cnblogs.com/annt/p/ant003.html
+{
+    QImage qImg;
+    if (cvImg.channels() == 3)//3 channels color image
+    {
+        cv::cvtColor(cvImg, cvImg, CV_BGR2RGB);
+        qImg = QImage((const unsigned char*)(cvImg.data),
+                      cvImg.cols, cvImg.rows,
+                      cvImg.cols*cvImg.channels(),
+                      QImage::Format_RGB888);
+    }
+    else if (cvImg.channels() == 1)//grayscale image
+    {
+        qImg = QImage((const unsigned char*)(cvImg.data),
+                      cvImg.cols, cvImg.rows,
+                      cvImg.cols*cvImg.channels(),
+                      QImage::Format_Indexed8);
+    }
+    else
+    {
+        qImg = QImage((const unsigned char*)(cvImg.data),
+                      cvImg.cols, cvImg.rows,
+                      cvImg.cols*cvImg.channels(),
+                      QImage::Format_RGB888);
+    }
+
+    return qImg;
 }
 
 void rgbImage::FillRgbImage(unsigned short *datacube)
 {
-    unsigned short *r_row, *g_row, *b_row;
+    //从第二行开始，向下移动一行，https://blog.csdn.net/u014686356/article/details/65937750
+//    m_matRgbImage->rowRange(0, m_matRgbImage->rows - 1).copyTo(m_matRgbImage->rowRange(1, m_matRgbImage->rows));//经tc验证：此行代码工作异常，为啥不加.clone()就异常？？？？？？
+//    m_matRgbImage->rowRange(0, m_matRgbImage->rows - 1).clone().copyTo(m_matRgbImage->rowRange(1, m_matRgbImage->rows));//此方式，ximea帧率130hz，1min左右就出现漏帧
 
-    if(m_iFrameCounter<m_iFrameNumber)
+//    cv::Mat upperPart = m_matRgbImage->rowRange(0, m_matRgbImage->rows - 1).clone();//此方式，ximea帧率130hz，1min左右就出现漏帧
+//    upperPart.copyTo(m_matRgbImage->rowRange(1, m_matRgbImage->rows));
+
+    for (int i = m_matRgbImage->rows - 2; i >= 0; --i)//此方式，ximea帧率130hz，4.5min左右出现漏帧 → 此方式效率最高
     {
-        FillOnerowofRgbImage(m_matRgbImage, m_iFrameCounter, datacube);
+        m_matRgbImage->row(i).copyTo(m_matRgbImage->row(i+1));
-//        std::cout << "小于：" << m_iFrameNumber << std::endl;
     }
-    else
-    {
-//        std::cout << "大于：" << m_iFrameNumber << std::endl;
 
-        //通过行赋值将前m_iFrameNumber-1行向上移动一行，https://blog.csdn.net/u014686356/article/details/65937750
+    FillOnerowofRgbImage(m_matRgbImage, 0, datacube);
-//        m_matRgbImage->rowRange(1, m_matRgbImage->rows).copyTo(m_matRgbImage->rowRange(0, m_matRgbImage->rows-1));
-        for (int i = 1; i < m_matRgbImage->rows; ++i)
-        {
-//            std::cout << "大于：" << i << std::endl;
-            m_matRgbImage->col(i).copyTo(m_matRgbImage->col(i-1));
-//            std::cout << "--------------" << i << std::endl;
-        }
 
+//    m_Qphoto = Mat2QImage(*m_matRgbImage);
 
-//        std::cout << "1111111111111111111111111111"<< std::endl;
+    //保存rgb图片
-        //通过FillOnerowofRgbImage为m_iFrameNumber行赋值
+//    if (m_iFrameCounter % m_iFramerate == 0 || m_iFrameCounter == m_iFrameNumber - 1)
-        FillOnerowofRgbImage(m_matRgbImage, m_iFrameNumber-1, datacube);
+//    {
-//        std::cout << "22222222222222222"<< std::endl;
+////        QString savePath = "/media/nvme/delete/" + QString::number(m_iFrameCounter) + "_qt.jpg";
-
+////        m_Qphoto.save(savePath);
-
-
-
-
-//        //循环给每行像素赋值
-//        r_row = datacube + 121 * m_iSampleNumber;
-//        g_row = datacube + 79 * m_iSampleNumber;
-//        b_row = datacube + 40 * m_iSampleNumber;
-//        for (int j = 0; j < m_iFrameNumber; j++)
-//        {
-//            p = m_matRgbImage.ptr<uchar>(j);
-//            for ( j = 0; j < nCols; ++j){
-//                p[j] = table[p[j]];
-//            }
 //
-//        }
+//        QString savePath_cv = "/media/nvme/delete/" + QString::number(m_iFrameCounter) + "_cv.jpg";
-
+//        cv::imwrite(savePath_cv.toStdString(), *m_matRgbImage);
-
+//    }
-
+//    m_VideoWriter.write(*m_matRgbImage);
-        //保存rgb图片
+//    std::string rgbFilePathNoStrech = "/media/nvme/delete/" + std::to_string(m_iFrameCounter) + "ctmp_image_no_strech.png";
-        if (m_iFrameCounter % m_iFramerate == 0 || m_iFrameCounter == m_iFrameNumber - 1)
+//    cv::imwrite(rgbFilePathNoStrech, *m_matRgbImage);
-        {
-            ////保存文件
-            //FileOperation * fileOperation = new FileOperation();
-            //string directory = fileOperation->getDirectoryOfExe();
-            //string rgbFilePathStrech = “/media/nvme/300TC/config/” + "\\tmp_image_strech.png";//没有拉伸图片
-//            std::string rgbFilePathNoStrech = "/media/nvme/300TC/config/" + std::to_string(m_iFrameCounter) + "ctmp_image_no_strech.png";
-
-            //m_QRgbImage->save(QString::fromStdString(rgbFilePathNoStrech), "PNG");
-
-//            cv::imwrite(rgbFilePathNoStrech, *m_matRgbImage);
-            //cv::imwrite(rgbFilePathStrech, CStretch(*m_matRgbImage, 0.01));
-
-        }
-        m_VideoWriter.write(*m_matRgbImage);
-        std::string rgbFilePathNoStrech = "/media/nvme/delete/" + std::to_string(m_iFrameCounter) + "ctmp_image_no_strech.png";
-        cv::imwrite(rgbFilePathNoStrech, *m_matRgbImage);
-    }
-
 
     m_iFrameCounter++;
 }

Source_Files/sbgrecorder.cpp

@@ -608,66 +608,43 @@ void sbgtc::SbgRecorder::parseSbgMessage(QByteArray * sbgMessage)
     //判断模式是否为: NAV_POSITION
     if(receivedMsgClass==SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_EKF_EULER)
     {
-        m_iSolutionModeCounter++;//
+        m_iSolutionModeCounter++;
 
         uint32_t status=logData.ekfEulerData.status;
-        uint32_t mode=status>>24;//?????????????????????????????????????
+        uint32_t mode=status & 0xf;
-//        uint32_t mode=status;//这是错的
 
         //一秒钟发射一次mode
         if(m_iSolutionModeCounter%200 == 0)
         {
             emit sbgSolutionModeSignal(mode);
+//            std::cout << "logData.ekfEulerData.status: " << status << std::endl;
 
-            switch (mode)
+            switch (mode) {
-            {
+                case SBG_ECOM_SOL_MODE_UNINITIALIZED:
-            case SBG_ECOM_SOL_MODE_UNINITIALIZED:
+//                    std::cout << "此刻模式为: " << "UNINITIALIZED" << std::endl;
-//                std::cout<<"此刻模式为: "<<"UNINITIALIZED"<<std::endl;
+                    m_bIsNAV_POSITION_MODE = false;
-                break;
+                    break;
-            case SBG_ECOM_SOL_MODE_VERTICAL_GYRO:
+                case SBG_ECOM_SOL_MODE_VERTICAL_GYRO:
-//                std::cout<<"此刻模式为: "<<"VERTICAL_GYRO"<<std::endl;
+//                    std::cout << "此刻模式为: " << "VERTICAL_GYRO" << std::endl;
-                break;
+                    m_bIsNAV_POSITION_MODE = false;
-            case SBG_ECOM_SOL_MODE_AHRS:
+                    break;
-//                std::cout<<"此刻模式为: "<<"AHRS"<<std::endl;
+                case SBG_ECOM_SOL_MODE_AHRS:
-                break;
+//                    std::cout << "此刻模式为: " << "AHRS" << std::endl;
-            case SBG_ECOM_SOL_MODE_NAV_VELOCITY:
+                    m_bIsNAV_POSITION_MODE = false;
-//                std::cout<<"此刻模式为: "<<"NAV_VELOCITY"<<std::endl;
+                    break;
-                break;
+                case SBG_ECOM_SOL_MODE_NAV_VELOCITY:
-            case SBG_ECOM_SOL_MODE_NAV_POSITION:
+//                    std::cout << "此刻模式为: " << "NAV_VELOCITY" << std::endl;
-//                std::cout<<"此刻模式为: "<<"NAV_POSITION"<<std::endl;
+                    m_bIsNAV_POSITION_MODE = false;
+                    break;
+                case SBG_ECOM_SOL_MODE_NAV_POSITION:
+//                    std::cout << "此刻模式为: " << "NAV_POSITION" << std::endl;
+                    m_bIsNAV_POSITION_MODE = true;
 
-                break;
+                    break;
-            default:
+                default:
-                break;
+                    break;
             }
         }
-
-        switch (mode)
-        {
-        case SBG_ECOM_SOL_MODE_UNINITIALIZED:
-//            std::cout<<"此刻模式为: "<<"UNINITIALIZED"<<std::endl;
-            m_bIsNAV_POSITION_MODE=false;
-            break;
-        case SBG_ECOM_SOL_MODE_VERTICAL_GYRO:
-//            std::cout<<"此刻模式为: "<<"VERTICAL_GYRO"<<std::endl;
-            m_bIsNAV_POSITION_MODE=false;
-            break;
-        case SBG_ECOM_SOL_MODE_AHRS:
-//            std::cout<<"此刻模式为: "<<"AHRS"<<std::endl;
-            m_bIsNAV_POSITION_MODE=false;
-            break;
-        case SBG_ECOM_SOL_MODE_NAV_VELOCITY:
-//            std::cout<<"此刻模式为: "<<"NAV_VELOCITY"<<std::endl;
-            m_bIsNAV_POSITION_MODE=false;
-            break;
-        case SBG_ECOM_SOL_MODE_NAV_POSITION:
-//            std::cout<<"此刻模式为: "<<"NAV_POSITION"<<std::endl;
-            m_bIsNAV_POSITION_MODE=true;
-
-            break;
-        default:
-            break;
-        }
     }
     else if(receivedMsgClass==SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_GPS1_POS)
     {
@@ -687,6 +664,10 @@ void sbgtc::SbgRecorder::parseSbgMessage(QByteArray * sbgMessage)
 
 //        std::cout<<"纬度精度为："<<maximal<<std::endl;
 //        std::cout<<"numSvUsed："<<satelliteCounter<<std::endl;
+//
+//        std::cout<<"latitude："<<logData.gpsPosData.latitude<<std::endl;
+//        std::cout<<"longitude："<<logData.gpsPosData.longitude<<std::endl;
+//        std::cout<<"altitude："<<logData.gpsPosData.altitude<<std::endl;
 
         emit sbgAccuracySignal(static_cast<int>(maximal), satelliteCounter);
 
@@ -727,7 +708,7 @@ void sbgtc::SbgRecorder::parseSbgMessage(QByteArray * sbgMessage)
 
 
     //控制开始采集高光谱影像,m_bIsNAV_POSITION_MODE &&
-    if(m_bIsRecordHyperspecatralImage && m_bIsSyncSystemTimeBaseGpstime && receivedMsgClass==SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_UTC_TIME)
+    if(m_bIsRecordHyperspecatralImage && m_bIsSyncSystemTimeBaseGpstime && m_bIsNAV_POSITION_MODE && receivedMsgClass==SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_UTC_TIME)
     {
         m_baseFileName=getFileNameBaseOnTime();
         emit sbgReady(calculateTimeDifferenceBetweenSystemAndSbg(logData),m_baseFileName);

Source_Files/udpserver.cpp

@@ -8,16 +8,16 @@ UdpServer::UdpServer()
     m_udpSocket->bind(45454, QUdpSocket::ShareAddress);
     connect(m_udpSocket, SIGNAL(readyRead()),this, SLOT(processPendingDatagrams()));
 
-    m_RecordSbgThread=new QThread();
-    m_sbgRecorder=new sbgtc::SbgRecorder();
-    m_sbgRecorder->moveToThread(m_RecordSbgThread);
-    m_RecordSbgThread->start();
-
     m_RecordThread=new QThread();
     m_imager=new XimeaImager();
     m_imager->moveToThread(m_RecordThread);
     m_RecordThread->start(QThread::HighestPriority);
 
+    m_RecordSbgThread=new QThread();
+    m_sbgRecorder=new sbgtc::SbgRecorder();
+    m_sbgRecorder->moveToThread(m_RecordSbgThread);
+    m_RecordSbgThread->start();
+
     m_CopyFileThread=new QThread();
     m_copyFile=new FileOperation();
     m_copyFile->moveToThread(m_CopyFileThread);
@@ -51,19 +51,41 @@ UdpServer::UdpServer()
 
     connect(m_imager, SIGNAL(ximeaImageStatus(int)),this, SLOT(sendXimeaImageStatus(int)));
     connect(m_imager, SIGNAL(autoExposeMaxValueOfOneFrame(int, double)),this, SLOT(sendXimeaAutoExposeMaxValueOfOneFrame(int, double)));
+    connect(m_imager, SIGNAL(binSignal(int, int)),this, SLOT(sendXimeaBinState(int, int)));
     connect(m_imager, SIGNAL(frameRateSignal(double)),this, SLOT(sendXimeaImageFrameRate(double)));
     connect(m_copyFile, SIGNAL(copyFileStatus(int)),this, SLOT(sendCopyFileStatus(int)));
 
+    QString ximeaParamCfgFile = "/media/nvme/300TC/config/StateOf300tc.cfg";
+    stateOf300tc.setConfigfilePath(ximeaParamCfgFile.toStdString());
+    if(!stateOf300tc.isConfigfileExist())
+        stateOf300tc.createConfigFile();
+    stateOf300tc.parseConfigfile();
 
+    stateOf300tc.setSbgState(0);
+    stateOf300tc.setSbgSolutionMode(0);
+    stateOf300tc.setXimeaState(100);
+    stateOf300tc.setFrameRate(0);
+    stateOf300tc.setExposeTime(0);
+    stateOf300tc.setExposeMaxValueOfOneFrame(0);
 
     //当软件不正常关闭并且重启后，通知其他psdk程序
     m_clientIpAddress=QHostAddress(QHostAddress::LocalHost);
     sendSerialPortStatus(0);
-    sendXimeaImageStatus(0);
+    sendXimeaImageStatus(100);
     sendCopyFileStatus(0);
 
+    system("sudo gpio write 10 0");
 
+    m_recordTempThread=new QThread();
+    m_300tcTemperature = new Record300TcTemperature();
+    m_300tcTemperature->moveToThread(m_recordTempThread);
+    m_recordTempThread->start();
+    connect(this, SIGNAL(record300tcTemperatureSignal(QString)),m_300tcTemperature, SLOT(recordTemperature(QString)));
 
+    QDateTime curDateTime = QDateTime::currentDateTime();
+    QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
+    QString Temperature300tcCSVPath = QDir::cleanPath(QString::fromStdString("/media/nvme/300TC/programRunLog/300tcTemperature") + QDir::separator() + "300tcTemperature_" + currentTime + ".csv");
+    emit record300tcTemperatureSignal(Temperature300tcCSVPath);
 
     std::cout<<"UdpServer::UdpServer--------:System ready!"<<std::endl;
 }
@@ -101,7 +123,7 @@ void UdpServer::processPendingDatagrams()
         case 2://关闭系统:关闭相机和sbg串口,关闭软件
         {
             std::cout<<"2代表关闭系统!"<<std::endl;
-
+            m_300tcTemperature->stopRecordTemperature();
 
             if(m_sbgRecorder->getSbgState()>=1)
             {
@@ -166,8 +188,8 @@ void UdpServer::processPendingDatagrams()
         {
             if(m_imager->getImagerState()>=101 && m_imager->getImagerState()<=103)
             {
-                float time = datagramList[1].toFloat();//ms
+                float time = datagramList[1].toFloat();//μs
-                m_imager->wrapSetExposureTime(time*1000);
+                m_imager->wrapSetExposureTime(time);
                 std::cout<<"7，手动设置曝光时间为：" << time <<std::endl;
             }
 
@@ -196,8 +218,30 @@ void UdpServer::processPendingDatagrams()
 
             break;
         }
+        case 10:
+        {
+            std::cout<<"10代表!"<<std::endl;
+
+            int sbgState,sbgSolutionMode,ximeaState,frameRate,exposeMaxValueOfOneFrame;
+            float exposeTime;
+
+            stateOf300tc.getSbgState(sbgState);
+            stateOf300tc.getSbgSolutionMode(sbgSolutionMode);
+            stateOf300tc.getXimeaState(ximeaState);
+            stateOf300tc.getFrameRate(frameRate);
+            stateOf300tc.getExposeTime(exposeTime);
+            stateOf300tc.getExposeMaxValueOfOneFrame(exposeMaxValueOfOneFrame);
+
+            sendSerialPortStatus(sbgState);
+            sendSbgSolutionModeState(sbgSolutionMode);
+            sendXimeaImageStatus(ximeaState);
+            sendXimeaAutoExposeMaxValueOfOneFrame(exposeMaxValueOfOneFrame, exposeTime);
+            sendXimeaImageFrameRate(frameRate);
+
+            break;
+        }
         default:
-            std::cout<<">=9没有意义!"<<std::endl;
+            std::cout<<">=11没有意义!"<<std::endl;
 
             break;
         }
@@ -259,6 +303,8 @@ void UdpServer::sendSerialPortStatus(int serialPortStatus)
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+
+    stateOf300tc.setSbgState(serialPortStatus);
 }
 
 void UdpServer::sendSbgSolutionModeState(int SolutionMode)
@@ -271,6 +317,8 @@ void UdpServer::sendSbgSolutionModeState(int SolutionMode)
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+
+    stateOf300tc.setSbgSolutionMode(SolutionMode);
 }
 
 void UdpServer::sendSbgAccuracyState(int Accuracy,int SatelliteCounter)
@@ -295,15 +343,32 @@ void UdpServer::sendXimeaImageStatus(int ximeaImageStatus)
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+
+    stateOf300tc.setXimeaState(ximeaImageStatus);
 }
 
 void UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame(int autoExposeMaxValueOfOneFrame, double exposeTime)
 {
+//    std::cout<<"UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame---------------------:"<< exposeTime << " " << autoExposeMaxValueOfOneFrame <<std::endl;
+
+    QByteArray datagram2send;
+
+    QString status = "XimeaAutoExpose," + QString::number(autoExposeMaxValueOfOneFrame) + "," + QString::number(exposeTime, 'f', 2);
+
+    datagram2send.operator =(status.toStdString().c_str());
+    m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+
+    stateOf300tc.setExposeTime(exposeTime);
+    stateOf300tc.setExposeMaxValueOfOneFrame(autoExposeMaxValueOfOneFrame);
+}
+
+void UdpServer::sendXimeaBinState(int spatialBin, int spectralBin)
+{
 //    std::cout<<"UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame---------------------:"<< ximeaImageStatus <<std::endl;
 
     QByteArray datagram2send;
 
-    QString status = "XimeaAutoExpose," + QString::number(autoExposeMaxValueOfOneFrame) + "," + QString::number(exposeTime, 'f', 2);
+    QString status = "bin," + QString::number(spatialBin) + "," + QString::number(spectralBin);
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
@@ -319,6 +384,8 @@ void UdpServer::sendXimeaImageFrameRate(double frameRate)
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+
+    stateOf300tc.setFrameRate(frameRate);
 }
 
 void UdpServer::sendCopyFileStatus(int fileStatus)
@@ -337,3 +404,199 @@ void UdpServer::onRecordFinished()
 {
     std::cout<<"UdpServer::onRecordFinished----------------:影像停止采集"<<std::endl;
 }
+
+Record300TcTemperature::Record300TcTemperature()
+{
+    m_bIsRecord = true;
+}
+
+void Record300TcTemperature::stopRecordTemperature()
+{
+    m_bIsRecord = false;
+}
+
+void Record300TcTemperature::recordTemperature(QString filePath= nullptr)
+{
+    if(filePath== nullptr)
+        filePath="300tcTemperature.csv";
+    QList<QString> fileInfo = getFileInfo(filePath);
+    bool ret = createDir(fileInfo[0]);
+
+    ofstream temperatureFile300Tc(filePath.toStdString().c_str(),ios::app);
+    int counter = 0;
+
+    m_serial=new QSerialPort();
+
+    if(m_serial->isOpen())//如果串口已经打开了 先给他关闭了
+    {
+        m_serial->clear();
+        m_serial->close();
+    }
+
+    QString portname = "ttyUSB2";
+
+    m_serial->setPortName(portname);
+    m_serial->open(QIODevice::ReadWrite);
+
+    bool x=m_serial->setBaudRate(9600);
+
+    QByteArray requestData;
+    while (m_bIsRecord)
+    {
+        counter++;
+        if(m_serial->waitForReadyRead(30000))
+        {
+            requestData = m_serial->readAll();
+
+            float temp = parseMessage(&requestData);
+            if (temp == -10000)
+            {
+                continue;
+            }
+
+            QDateTime curDateTime = QDateTime::currentDateTime();
+            QString currentTime = curDateTime.toString("yyyy/MM/dd hh:mm:ss");
+
+            temperatureFile300Tc << currentTime.toStdString() << "," << temp << "\n";
+
+//            if(temp > 80)
+//            {
+//                system("/home/300tc/projects/udpClient/udpClient 127.0.0.1 9,0");
+//            }
+//            if(temp > 90)
+//            {
+//                system("/home/300tc/projects/udpClient/udpClient 127.0.0.1 2");
+//            }
+//
+            if (counter % 60 == 0)
+            {
+                temperatureFile300Tc.flush();
+            }
+            sleep(1);
+        }
+        else
+        {
+//            std::cout<<"Record300TcTemperature::recordTemperature--Wait response timeout."<<std::endl;
+        }
+    }
+    m_bIsRecord = true;
+
+    temperatureFile300Tc.close();
+}
+
+float Record300TcTemperature::parseMessage(QByteArray * data)
+{
+    float Lux;
+    float T;
+    float P;
+    float Hum;
+    float H;
+    bool hasTemperature = false;
+
+//    qDebug() << "Received data(hex): " << data->toHex();
+
+//    for (int i = 0; i < data->length(); ++i)
+//    {
+//        qDebug() << i << ":" << (int)data->at(i);
+//    }
+
+    QByteArray target = QByteArray::fromHex("5a5a"); // The pattern to search for
+
+    int offset_tmp = data->indexOf(target);
+    QList<int> offsets;
+
+    while (offset_tmp != -1)
+    {
+        offsets.append(offset_tmp);
+        offset_tmp = data->indexOf(target, offset_tmp + target.size());
+    }
+
+    if (offsets.isEmpty())
+    {
+//        qDebug() << "5A5A not found in the data.";
+        return -10000;
+    }
+//    qDebug() << "5A5A found at offsets:" << offsets;
+
+    for (int i = 0; i < offsets.length(); ++i)
+    {
+        int offset = offsets.at(i);
+
+        int messageClass = data->at(offset + 2);
+        int messageCount = data->at(offset + 3) + 5;
+//        qDebug() << "messageCount:" << messageCount;
+        if (offset + messageCount - 1 > data->length() - 1)
+        {
+            qDebug() << i << ": Some data of this frame is missing! Discarding the frame.";
+            continue;
+        }
+
+
+        int checksum = 0;
+        QList<int> numbers;
+        for (int j = 0; j < messageCount - 1; ++j)
+        {
+            if (i==offsets.length()-1 && j== messageCount-1)
+            {
+                int sdf=1;
+            }
+
+            int index = offset + j;
+
+            if (index >= data->length())//Some data of this frame is missing! Discarding the frame.
+            {
+                checksum = -1;
+                break;
+            }
+            int tmp = static_cast<int>(data->at(index));
+            numbers.append(tmp);
+            checksum += tmp;
+        }
+//        qDebug() << "jiaqilai:" << numbers;
+
+        if (checksum == -1)
+        {
+            qDebug() << "Some data of this frame is missing! Discarding the frame.";
+            continue;
+        }
+
+        if ((checksum & 0xFF) != data->at(offset + messageCount - 1))
+        {
+            qDebug() << "Checksum mismatch! Discarding the frame.";
+            continue;
+        }
+
+        //parse data
+        switch (messageClass)
+        {
+            case 0x15:
+                Lux = (float)((data->at(offset + 4)<<24)|(data->at(offset + 5)<<16)|(data->at(offset + 6)<<8)|data->at(offset + 7)) / 100;
+//                qDebug() << "lux: " << Lux;
+                break;
+            case 0x45:
+                T = (float)((data->at(offset + 4)<<8)|data->at(offset + 5)) / 100;
+                P = (float)((data->at(offset + 6)<<24)|(data->at(offset + 7)<<16)|(data->at(offset + 8)<<8)|data->at(offset + 9)) / 100;
+                Hum = (float)((data->at(offset + 10)<<8) | data->at(offset + 11)) / 100;
+                H = (float)((data->at(offset + 12)<<8)|data->at(offset + 13));
+
+                hasTemperature = true;
+
+//                qDebug() << "T: " << T;
+//                qDebug() << "P: " << P;
+//                qDebug() << "Hum: " << Hum;
+//                qDebug() << "H: " << H;
+                break;
+            default : // 可选的
+                ;
+
+        }
+    }
+    if (hasTemperature)
+    {
+        return T;
+    }
+    else
+    {
+        return -10000;
+    }
+}

Source_Files/ximeaimager.cpp

@@ -7,16 +7,35 @@ XimeaImager::XimeaImager()
     m_iFrameCounter=0;
     m_iImagerState=100;
 
-    //connect(this, SIGNAL(recordFinished()),this, SLOT());
-
     QString ximeaCfgFile = "/media/nvme/300TC/config/ximea.cfg";
     m_configfile.setConfigfilePath(ximeaCfgFile.toStdString());
     if(!m_configfile.isConfigfileExist())
         m_configfile.createConfigFile();
     m_configfile.parseConfigfile();
+    m_configfile.getWindowOffsety_HeightOfSpectral(m_iOffsetyOfSpectralBin1, m_iHeightOfSpectralBin1, "bin1");
+    m_configfile.getWindowOffsety_HeightOfSpectral(m_iOffsetyOfSpectralBin2, m_iHeightOfSpectralBin2, "bin2");
+    //检查 ximea.cfg 是否满足要求
+    if(m_iOffsetyOfSpectralBin2 != m_iOffsetyOfSpectralBin1 / 2)
+    {
+        std::cout<<"ximea.cfg 错误：m_iOffsetyOfSpectralBin2 != m_iOffsetyOfSpectralBin1 / 2!"<<std::endl;
+    }
+    if(m_iOffsetyOfSpectralBin2 % 2 != 0)
+    {
+        std::cout<<"ximea.cfg 错误：m_iOffsetyOfSpectralBin2 不是 2 的倍数，ximea相机不接受!"<<std::endl;
+    }
+    if(m_iHeightOfSpectralBin1 < m_iHeightOfSpectralBin2 * 2)
+    {
+        std::cout<<"ximea.cfg 错误：bin1 波段数小于 bin2 波段数的 2 倍!"<<std::endl;
+    }
+
+    QString ximeaParamCfgFile = "/media/nvme/300TC/config/ximeaParam.cfg";
+    m_parameterConfigfile.setConfigfilePath(ximeaParamCfgFile.toStdString());
+    if(!m_parameterConfigfile.isConfigfileExist())
+        m_parameterConfigfile.createConfigFile();
+    m_parameterConfigfile.parseConfigfile();
 
     m_recordTempThread=new QThread();
-    m_ximeaTemperature = new RecordXimeaTemperature(&m_imager);
+    m_ximeaTemperature = new RecordXimeaTemperature(&m_imager, this);
     m_ximeaTemperature->moveToThread(m_recordTempThread);
     m_recordTempThread->start();
 
@@ -28,8 +47,15 @@ XimeaImager::XimeaImager()
     writeData2DiskThread->start(QThread::HighestPriority);
     connect(this, SIGNAL(startWriteDiskSignal()), writeData2Disk, SLOT(write2Disk()));
 
+    m_pushFlowThread=new QThread();
+    m_pushFlow = new PushFlow();
+    m_pushFlow->moveToThread(m_pushFlowThread);
+    m_pushFlowThread->start();
+    connect(this, SIGNAL(startPushFlowSignal()), m_pushFlow, SLOT(encodePushFlow()));
+
     m_pool = new MemoryPool<DataBuffer>;
     q = new queue<DataBuffer *>;
+    m_qFrameCounter = new queue<int>;
 
     m_rgbImage = new rgbImage();
 }
@@ -63,10 +89,14 @@ void XimeaImager::openImger()
         {
             bool haha = m_imager.setSpectralBin(spectralBin);
             bool haha2 = m_imager.setSpatialBin(spatialBin);
+
+            emit binSignal(spatialBin, spectralBin);
+            std::cout<<"spectralBin："<< spectralBin <<std::endl;
+            std::cout<<"spatialBin："<< spatialBin <<std::endl;
         }
 
         float gain, offset;//用于生成头文件中的波长信息
-        ret = m_configfile.getGainOffset(gain, offset);
+        ret = m_configfile.getGainOffsetOfSpectralBin1(gain, offset);
         if (ret)
         {
             m_imager.setGainOffset(gain, offset);
@@ -76,10 +106,24 @@ void XimeaImager::openImger()
         ret = m_configfile.getEffectiveWindow(width, offsetx, height, offsety);
         if (ret)
         {
+            int rgbHeight;
+            int framerateVideo;
+            m_configfile.getPushFlowParam(m_iFlowSwitch, rgbHeight, framerateVideo);
+            std::cout <<"rgbHeight：" << rgbHeight << ", framerateVideo：" << framerateVideo << std::endl;
+
             m_imager.setEffectiveWindow(offsetx, width, offsety, height);
-            m_rgbImage->SetRgbImageWidthAndHeight(height, width, 20);
+            m_rgbImage->SetRgbImageWidthAndHeight(height, width, rgbHeight);
+            m_pushFlow->setParm(m_rgbImage,width,rgbHeight,framerateVideo);
+
+            int redBandNumber;
+            int greenBandNumber;
+            int blueBandNumber;
+            getRgbBandNumber(redBandNumber, greenBandNumber, blueBandNumber);
+            m_rgbImage->SetRgbBandNumber(redBandNumber, greenBandNumber, blueBandNumber);
+
             std::cout<<"height："<< height <<std::endl;
             std::cout<<"width："<< width <<std::endl;
+            std::cout<<"每帧字节数："<< width * height * 2 <<std::endl;
         }
 
 //        int width_roi = 0, offsetx_roi = 0;
@@ -89,7 +133,32 @@ void XimeaImager::openImger()
 //            m_imager.setEffectiveWindowRoi(offsetx_roi, width_roi);
 //        }
 
-        setFramerate(100);
+        int bufferPolicy, acqBufferSize;
+        ret1 = m_configfile.getBufferPolicy(bufferPolicy);
+        if (ret1)
+        {
+            m_imager.setBufferPolicy(bufferPolicy);
+        }
+        ret1 = m_configfile.getAcqBufferSize(acqBufferSize);
+        if (ret1)
+        {
+            m_imager.setAcqBufferSize(acqBufferSize);
+        }
+
+        if (m_parameterConfigfile.isConfigfileExist())
+        {
+            int frameRate;
+            m_parameterConfigfile.getFrameRate(frameRate);
+            setFramerate(frameRate);
+
+            float exposeTime;
+            m_parameterConfigfile.getExposeTime(exposeTime);
+            wrapSetExposureTime(exposeTime);
+        }
+        else
+        {
+            setFramerate(100);
+        }
 
         //经验证：frameSizeManual和frameSizeAuto相等
         int frameSizeManual = m_imager.get_band_count()*m_imager.get_sample_count()*2;
@@ -105,7 +174,7 @@ void XimeaImager::openImger()
 
         QDateTime curDateTime = QDateTime::currentDateTime();
         QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
-        m_ximeaTemperatureCSVPath = QDir::cleanPath(QString::fromStdString("/home/programRunLog/hyperspectralLog") + QDir::separator() + "ximeaTemperature_" + currentTime + ".csv");
+        m_ximeaTemperatureCSVPath = QDir::cleanPath(QString::fromStdString("/media/nvme/300TC/programRunLog/ximeaTemperature") + QDir::separator() + "ximeaTemperature_" + currentTime + ".csv");
 //        m_ximeaTemperatureCSVPath = "/home/ximeaTemperature.csv";
         emit recordXimeaTemperatureSignal(m_ximeaTemperatureCSVPath);
     }
@@ -154,14 +223,21 @@ void XimeaImager::setFramerate(double framerate)
     {
         m_imager.set_framerate(framerate);
 
-        int maxExposureTimeInUs=1/framerate*1000000*0.01;
+        int exposureTimeInUs = getExposureTime();
-        setExposureTime(maxExposureTimeInUs);
+
-//        setExposureTime(1000);
+        int maxExposureTimeInUs=1/framerate*1000000;
+
+        if (exposureTimeInUs > maxExposureTimeInUs)
+        {
+            wrapSetExposureTime(maxExposureTimeInUs);
+        }
 
         m_iImagerState=102;
         emit ximeaImageStatus(m_iImagerState);
 
         emit frameRateSignal(framerate);
+
+        m_parameterConfigfile.setFrameRate(framerate);
     }
     catch(int xiApiErrorCodes)
     {
@@ -197,9 +273,7 @@ double XimeaImager::setExposureTime(float exposureTime_in_us)
         //确保设置的积分时间比最大积分时间小
         if(exposureTime_in_us<maxExposureTime_in_us)
         {
-
             m_imager.set_integration_time(exposureTime_in_us);
-
         }
         else
         {
@@ -208,6 +282,7 @@ double XimeaImager::setExposureTime(float exposureTime_in_us)
 
         //返回设置的积分时间
         integrationTime2Return=m_imager.get_integration_time();
+        m_parameterConfigfile.setExposeTime(integrationTime2Return);
 
         return integrationTime2Return;
     }
@@ -231,7 +306,7 @@ int XimeaImager::wrapSetExposureTime(float exposureTime_in_us)
     m_iImagerState=103;
     emit ximeaImageStatus(m_iImagerState);
 
-    emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime/1000);
+    emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime);
 
     return maxValueOfOneFrame;
 }
@@ -294,7 +369,7 @@ double XimeaImager::autoExposure()
 
         m_iImagerState=103;
         emit ximeaImageStatus(m_iImagerState);
-        emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime/1000);
+        emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime);
 
         std::cout<<"自动曝光完成!"<<std::endl;
         return exposureTime;
@@ -431,6 +506,65 @@ double XimeaImager::geWavelengthAtBand(int x)
     }
 }
 
+void XimeaImager::getRgbBandNumber(int &redBandNumber, int &greenBandNumber, int &blueBandNumber)
+{
+    vector<double> wavelengths;
+    if (m_imager.getSpectralBin() == 1)
+    {
+        for (int i = getWindowStartBand(); i < getWindowEndBand(); i++)
+        {
+            wavelengths.push_back(geWavelengthAtBand(i));
+        }
+    }
+    else if (m_imager.getSpectralBin() == 2)
+    {
+        for (int i = m_iOffsetyOfSpectralBin2; i < m_iOffsetyOfSpectralBin2 + m_iHeightOfSpectralBin2; i++)
+        {
+            if (i*2 + 1 > m_iOffsetyOfSpectralBin1 + m_iHeightOfSpectralBin1)
+            {
+                printf("XimeaImager::writeHdr 出现错误：窗口中，光谱 bin1 波段数小于 bin2 的 2 倍。\n");
+                break;
+            }
+            wavelengths.push_back((geWavelengthAtBand(i*2) + geWavelengthAtBand(i*2 + 1)) / 2);
+        }
+    }
+
+    //envi打开文件时的红绿蓝波长（nm）
+    int r_envi = 640;
+    int g_envi = 550;
+    int b_envi = 470;
+    redBandNumber = findClosestIndex(wavelengths, r_envi);
+    greenBandNumber = findClosestIndex(wavelengths, g_envi);
+    blueBandNumber = findClosestIndex(wavelengths, b_envi);
+
+//    std::cout<<"红波段的波段号："<< redBandNumber <<std::endl;
+//    std::cout<<"绿波段的波段号："<< greenBandNumber <<std::endl;
+//    std::cout<<"蓝波段的波段号："<< blueBandNumber <<std::endl;
+}
+
+int XimeaImager::findClosestIndex(const std::vector<double>& numbers, double target)
+{
+    if (numbers.empty()) {
+        // 处理空向量的情况
+        return -1;
+    }
+
+    double minDifference = std::abs(numbers[0] - target);
+    int closestIndex = 0;
+
+    for (int i = 1; i < numbers.size(); ++i)
+    {
+        double currentDifference = std::abs(numbers[i] - target);
+        if (currentDifference < minDifference)
+        {
+            minDifference = currentDifference;
+            closestIndex = i;
+        }
+    }
+
+    return closestIndex;
+}
+
 int XimeaImager::getMaxValueOfOneFrame(unsigned short * data, int numberOfPixel)
 {
     //排序
@@ -461,15 +595,41 @@ int XimeaImager::getImagerState() const
     return m_iImagerState;
 }
 
+double XimeaImager::calculateTimeDifferenceBetweenSbgAndximea(XI_IMG * image, double timeDifferenceBetweenSbgAndOS)
+{
+    printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--timeDifferenceBetweenSbgAndOS: %f s\n", timeDifferenceBetweenSbgAndOS);
+
+    double ximeaTime=image->tsSec + image->tsUSec/1000000;
+
+    printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--ximeaTime: %f s\n", ximeaTime);
+
+    //获取系统时间（纳秒）
+    struct timespec systemTime;
+    clock_gettime(CLOCK_REALTIME,&systemTime);
+    tm systemTime_rili;
+    localtime_r(&systemTime.tv_sec, &systemTime_rili);
+
+    double secondSystem=(systemTime_rili.tm_mday-1)*24*60*60+systemTime_rili.tm_hour*60*60+systemTime_rili.tm_min*60+systemTime_rili.tm_sec;
+    double timeOS=secondSystem+static_cast<double>(systemTime.tv_nsec)/1000000000;
+
+    printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--osTime: %f s\n", timeOS);
+
+
+    //计算系统时间和gps时间之间的差距
+    double timeDifferenceBetweenSbgAndximea = timeOS - timeDifferenceBetweenSbgAndOS - ximeaTime;
+
+    printf("XimeaImager::calculateTimeDifferenceBetweenSystemAndximea--timeDifferenceBetweenSbgAndximea: %f s\n", timeDifferenceBetweenSbgAndximea);
+
+    return timeDifferenceBetweenSbgAndximea;
+}
+
 void XimeaImager::startRecord(double TimeDifferenceBetweensOSAndSbg,QString baseFileName)
 {
-    m_ximeaTemperature->stopRecordTemperature();//开始采集影像前，停止获取相机的温度，以免降低帧率；
     try
     {
         if(m_iImagerState <= 99 || m_iImagerState==100 || m_iImagerState==104)
         {
-            emit ximeaImageStatus(m_iImagerState);
+            printf("已经开始采集----------------------------!\n");
-
             return;
         }
 
@@ -487,16 +647,35 @@ void XimeaImager::startRecord(double TimeDifferenceBetweensOSAndSbg,QString base
 
         m_baseFileName=baseFileName;
 
-
+        std::cout << "帧率为：" << getFramerate() << "hz" <<std::endl;
-        QString timesFileName=m_baseFileName+".times";
+        std::cout << "曝光时间为：" << getExposureTime() << "μs" <<std::endl;
-        FILE *hHimesFile=fopen(timesFileName.toStdString().c_str(),"w+");
-        std::cout << "曝光时间为：" << getExposureTime()/1000 << "ms" <<std::endl;
 
         using namespace std;
 //        ofstream timesFileHandle(timesFileName.toStdString()+"_ofstream");
 
-        writeData2Disk->setParm(q,m_baseFileName,m_iFrameSizeInByte, m_pool, m_rgbImage);
+        int number_WriteDisk = 100;
-        emit startWriteDiskSignal();
+        writeData2Disk->setParm(q, m_qFrameCounter,m_baseFileName,m_iFrameSizeInByte, number_WriteDisk, m_pool, m_rgbImage);
+//        emit startWriteDiskSignal();
+
+        int indexofbuff;
+        DataBuffer * buffer;
+
+        QString timesFileName=m_baseFileName+".times";
+        FILE *hHimesFile=fopen(timesFileName.toStdString().c_str(),"w+");
+//        ofstream timesFile(timesFileName.toStdString());
+        double timeDifferenceBetweenSbgAndXimea;
+        double * sbgTimeBuffer = new double[number_WriteDisk];
+
+        QString imageFileName=m_baseFileName+".bil";
+        FILE *hFile=fopen(imageFileName.toStdString().c_str(),"w+b");
+        double * imageBuffer = new double[number_WriteDisk];
+
+        QString vedioFileName=m_baseFileName+".h264";
+        m_pushFlow->setVedioFilePath(vedioFileName);
+        if(m_iFlowSwitch == 1)
+        {
+            emit startPushFlowSignal();
+        }
 
         m_imager.start();
         struct timeval timeStart, timeEnd;
@@ -505,75 +684,83 @@ void XimeaImager::startRecord(double TimeDifferenceBetweensOSAndSbg,QString base
         while (m_bRecordControl)
         {
             unsigned short *x=m_imager.get_frame(m_buffer);
-
-            //fwrite(m_buffer,2,getBandCount()*getSampleCount(),hFile);
-//            fwrite(m_imager.m_image.bp,static_cast<int>(m_imager.m_image.bp_size),1,hFile);
-            //fflush(hFile);//只保证了将IO缓冲写入系统缓冲中，使IO读操作能成功，但系统什么时候写入磁盘，由系统决定，一般是达到一定量时系统他就写入磁盘。
-            //sync();//强制系统将系统文件缓冲的内容写入磁盘
-
-
-
-            r_qtx.lock();
-            DataBuffer * buffer = m_pool->newElement();
-            r_qtx.unlock();
-//            m_pool->construct(buffer);
-
-//            memcpy(buffer->data,(unsigned short *)m_imager.m_image.bp,m_iFrameSizeInByte/2);
-            memcpy((void *)buffer->data,m_imager.m_image.bp,m_iFrameSizeInByte);
-
-            r_qtx.lock();
-            q->push(buffer);
-            r_qtx.unlock();//
-
-//            std::cout<<"XimeaImager::startRecord，队列长度为："<< q->size() <<std::endl;//
-
-//            fwrite(buffer,1,m_iFrameSizeInByte,hFile);
-
             m_iFrameCounter+=1;
 
-            double sbgTime=getSbgTime(TimeDifferenceBetweensOSAndSbg);
+            if (m_iFrameCounter == 1)
+            {
+                timeDifferenceBetweenSbgAndXimea = calculateTimeDifferenceBetweenSbgAndximea(&m_imager.m_image, TimeDifferenceBetweensOSAndSbg);
+            }
+            fwrite(m_imager.m_image.bp,1,m_iFrameSizeInByte, hFile);
+            //构造rgb图像，用于推流到m300遥控器
+            if(m_iFlowSwitch == 1)
+            {
+                m_rgbImage->FillRgbImage((unsigned short *)m_imager.m_image.bp);
+            }
 
-            fprintf(hHimesFile,"%f\n",sbgTime);
+            indexofbuff = m_iFrameCounter % number_WriteDisk;
-            //fwrite(&sbgTime,sizeof(double),1,hHimesFile);
 
-//            timesFileHandle << sbgTime << "\n";
+            if (indexofbuff == 0)
-//            std::cout<<"XimeaImager::startRecord---std::cout: "<<sbgTime<<std::endl;
+            {
+                sbgTimeBuffer[number_WriteDisk - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
+            }
+            else
+            {
+                sbgTimeBuffer[indexofbuff - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
+            }
 
-//            unsigned char pixel = *(unsigned char*)image.bp;//Default value: XI_MONO8
+            if (indexofbuff == 0)
-//            unsigned short pixel =*(unsigned short*)image.bp;//XI_RAW16
+            {
-//            printf("Image %d (%dx%d) received from camera. First pixel value: %d\n", m_iFrameCounter, (int)image.width, (int)image.height, pixel);
+                for (int i = 0; i < number_WriteDisk; ++i)
+                {
+                    fprintf(hHimesFile,"%f\n",sbgTimeBuffer[i]);
+                }
+            }
+        }
+        if (indexofbuff != 0)
+        {
+            for (int i = 0; i < indexofbuff; ++i)
+            {
+                fprintf(hHimesFile,"%f\n",sbgTimeBuffer[i]);
+            }
+
+            std::cout << "没凑满: " << indexofbuff <<std::endl;
         }
         gettimeofday(&timeEnd, NULL);
         runTime = (timeEnd.tv_sec - timeStart.tv_sec ) + (double)(timeEnd.tv_usec -timeStart.tv_usec)/1000000;
         m_imager.stop();
+        writeData2Disk->exitWriteData2Disk();
+        writeHdr();
+
+        m_pushFlow->exitPushFlow();
+
+        delete[] sbgTimeBuffer;
 
         double frameInTheory=runTime * getFramerate();
-        double frameLossed=frameInTheory - m_iFrameCounter;
-        double frameLossRate=frameLossed / frameInTheory;
 
-        std::cout<<"当前采集文件为: "<<baseFileName.toStdString()<<std::endl;
+        double frameLossed = m_imager.m_image.acq_nframe - m_iFrameCounter;
-        std::cout<<"采集时间为: "<<runTime<< "s" <<std::endl;
+        double frameLossRate = frameLossed / m_imager.m_image.acq_nframe;
+
+        std::cout<<"当前采集文件为: "<<baseFileName.toStdString()<< ".bil" <<std::endl;
+        std::cout<<"采集时间为: "<<runTime/60<< " min" <<std::endl;
         std::cout<<"当前帧率为: "<<getFramerate() << "hz" <<std::endl;
         std::cout<<"每秒数据量为: "<<getFramerate()*m_iFrameSizeInByte/(1024*1024)<<"MB"<<std::endl;
-        std::cout<<"理论采集帧数为: "<<frameInTheory<<std::endl;
+        std::cout<<"理论采集帧数为: "<<m_imager.m_image.acq_nframe<<std::endl;
         std::cout<<"实际采集帧数为："<<m_iFrameCounter<<std::endl;
         std::cout<<"丢失帧数为: "<<frameLossed<<std::endl;
         std::cout<<"丢帧率为: "<<frameLossRate * 100<< "%" <<std::endl;
 
         fclose(hHimesFile);
+        fclose(hFile);
 //        timesFileHandle.close();
+//        timesFile.close();
 
         timeStr = formatTimeStr(timeFormat);
         printf("停止采集：%s!\n", timeStr.toStdString().c_str());
 
-        writeHdr();
-
         m_iImagerState=m_iImagerStateTemp;
         emit ximeaImageStatus(m_iImagerState);
 
         emit recordFinished();
-
-        emit recordXimeaTemperatureSignal(m_ximeaTemperatureCSVPath);//停止采集影像后，继续获取传感器温度；
     }
     catch(int xiApiErrorCodes)
     {
@@ -613,16 +800,43 @@ void XimeaImager::writeHdr()
     hdrFileHandle << "wavelength units = nanometers\n";
     hdrFileHandle << "wavelength = {";
     //hdrFileHandle << std::setprecision(5);
-    for (int i = getWindowStartBand(); i < getWindowEndBand(); i++)
+
+    if (m_imager.getSpectralBin() == 1)
     {
-        hdrFileHandle << geWavelengthAtBand(i);
+        for (int i = getWindowStartBand(); i < getWindowEndBand(); i++)
-        if (i < getWindowEndBand() - 1)
-            hdrFileHandle << ", ";
-        else
         {
-            printf("头文件中写入了多少个波段:%d\n",i-getWindowStartBand()+1);//???????????????
+            hdrFileHandle << geWavelengthAtBand(i);
+            if (i < getWindowEndBand() - 1)
+                hdrFileHandle << ", ";
+            else
+            {
+                printf("头文件中写入了多少个波段:%d\n",i-getWindowStartBand()+1);//???????????????
+            }
         }
     }
+    else if (m_imager.getSpectralBin() == 2)
+    {
+        int counter = 0;
+        for (int i = m_iOffsetyOfSpectralBin2; i < m_iOffsetyOfSpectralBin2 + m_iHeightOfSpectralBin2; i++)
+        {
+            if (i*2 + 1 > m_iOffsetyOfSpectralBin1 + m_iHeightOfSpectralBin1)
+            {
+                printf("XimeaImager::writeHdr 出现错误：窗口中，光谱 bin1 波段数小于 bin2 的 2 倍。\n");
+                break;
+            }
+
+            hdrFileHandle << (geWavelengthAtBand(i*2) + geWavelengthAtBand(i*2 + 1)) / 2;
+            counter++;
+            if (i < m_iOffsetyOfSpectralBin2 + m_iHeightOfSpectralBin2 - 1)
+                hdrFileHandle << ", ";
+            else
+            {
+                printf("头文件中写入了多少个波段:%d\n", counter);
+            }
+        }
+    }
+
+
     hdrFileHandle << "}\n";
     hdrFileHandle.close();
 }
@@ -701,6 +915,18 @@ void XimeaImager::processXiApiErrorCodes(int xiApiErrorCodes)
         m_iImagerState=xiApiErrorCodes;
         emit ximeaImageStatus(m_iImagerState);
 
+        break;
+    case 10:
+        std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Timeout!"<<std::endl;
+        m_iImagerState=xiApiErrorCodes;
+        emit ximeaImageStatus(m_iImagerState);
+
+        break;
+    case 11:
+        std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Invalid arguments supplied!"<<std::endl;
+        m_iImagerState=xiApiErrorCodes;
+        emit ximeaImageStatus(m_iImagerState);
+
         break;
     case 12:
         std::cout<<"XimeaImager::processXiApiErrorCodes-----------:Not supported!"<<std::endl;
@@ -727,20 +953,26 @@ void XimeaImager::processXiApiErrorCodes(int xiApiErrorCodes)
 
         break;
     default:
-        QString ximeaError="ximeaError.txt";
-        ofstream ximeaErrorFile(ximeaError.toStdString().c_str(),ios::app);
-
-        ximeaErrorFile<< xiApiErrorCodes << "\n";
-        std::cout<<"XimeaImager::processXiApiErrorCodes-----------:未处理ximea异常代码："<< xiApiErrorCodes <<std::endl;
-
-        ximeaErrorFile.close();
-
-
-
         m_iImagerState=99;
         emit ximeaImageStatus(m_iImagerState);
         break;
     }
+
+    writeXiApiErrorCodes("/media/nvme/300TC/ximeaError.txt", xiApiErrorCodes);
+}
+
+void XimeaImager::writeXiApiErrorCodes(QString filePath, int xiApiErrorCodes)
+{
+    ofstream ximeaErrorFile(filePath.toStdString().c_str(),ios::app);
+
+    char * timeFormat="%Y%m%d_%H%M%S";
+    QString timeStr = formatTimeStr(timeFormat);
+
+    ximeaErrorFile<< timeStr.toStdString().c_str() << ": " << xiApiErrorCodes << "\n";
+
+    std::cout<<"XimeaImager::writeXiApiErrorCodes-----------:xiApiErrorCodes: "<<timeStr.toStdString().c_str()<< ": " << xiApiErrorCodes<<std::endl;
+
+    ximeaErrorFile.close();
 }
 
 void XimeaImager::stopRecord()
@@ -762,10 +994,12 @@ DataBuffer::~DataBuffer()
 {
 }
 
-RecordXimeaTemperature::RecordXimeaTemperature(Iris::IrisXimeaImager * imager)
+RecordXimeaTemperature::RecordXimeaTemperature(Iris::IrisXimeaImager * imager, XimeaImager * ximeaImager)
 {
     m_imager = imager;
     m_bIsRecord = true;
+
+    m_ximeaImager = ximeaImager;
 }
 
 void RecordXimeaTemperature::stopRecordTemperature()
@@ -777,19 +1011,56 @@ void RecordXimeaTemperature::recordTemperature(QString filePath= nullptr)
 {
     if(filePath== nullptr)
         filePath="ximeaTemperature.csv";
-    ofstream ximeaTemperatureFile(filePath.toStdString().c_str(),ios::app);
+    QList<QString> fileInfo = getFileInfo(filePath);
+    bool ret = createDir(fileInfo[0]);
 
+    ofstream ximeaTemperatureFile(filePath.toStdString().c_str(),ios::app);
+    int counter = 0;
     while(m_bIsRecord)
     {
+        counter++;
+
         float temp = m_imager->getTemperature();
+        if(temp > 80 && m_ximeaImager->getImagerState() == 104)
+        {
+            ximeaTemperatureFile.flush();
+            system("/home/300tc/projects/udpClient/udpClient 127.0.0.1 9,0");
+        }
+        if(temp > 90)
+        {
+            ximeaTemperatureFile.flush();
+            system("/home/300tc/projects/udpClient/udpClient 127.0.0.1 2");
+        }
+
+        // 获取剩余硬盘空间和剩余采集时间
+        FILE *fp;
+        char buffer[128];
+        fp = popen("cat /sys/devices/virtual/thermal/thermal_zone1/temp", "r");
+        if (fp == NULL) {
+            perror("popen");
+        }
+
+        // 读取输出并处理
+        unsigned long long temper;
+        if (fgets(buffer, sizeof(buffer), fp) != NULL)
+        {
+            temper = strtoull(buffer, NULL, 10);
+//            printf("CPU温度: %.2f;\n", (float)temper/1000);
+        }
+        pclose(fp);
 
         QDateTime curDateTime = QDateTime::currentDateTime();
         QString currentTime = curDateTime.toString("yyyy/MM/dd hh:mm:ss");
 
-        ximeaTemperatureFile << currentTime.toStdString() << "," << temp << "\n";
+        ximeaTemperatureFile << currentTime.toStdString() << "," << temp << "," << (float)temper/1000 << "\n";
 
 //        std::cout<<"RecordXimeaTemperature::recordTemperature----------------:ximea Temperature is "<< temp <<std::endl;
+//        std::cout<<"RecordXimeaTemperature::recordTemperature----------------:ximea state is "<< m_ximeaImager->getImagerState() <<std::endl;
 
+        if (counter % 60 == 0)
+        {
+            ximeaTemperatureFile.flush();
+        }
         sleep(1);
     }
 
@@ -800,6 +1071,7 @@ void RecordXimeaTemperature::recordTemperature(QString filePath= nullptr)
 
 WriteData2Disk::WriteData2Disk()
 {
+    isExitWriteData2Disk = false;
 }
 
 void WriteData2Disk::write2Disk()
@@ -807,60 +1079,287 @@ void WriteData2Disk::write2Disk()
     QString imageFileName=m_QbaseFileName+".bil";
     FILE *hFile=fopen(imageFileName.toStdString().c_str(),"w+b");
 
-    int sleepCounters=1;
+
     int frameCounter = 0;
-    unsigned short * dataBuffer = new unsigned short[m_iFrameSizeInByte/2];
+    int frameNumber;
+    unsigned short * dataBuffer = new unsigned short[m_iFrameSizeInByte/2*m_iNumber_WriteDisk];
+    isExitWriteData2Disk = false;
     while(true)
     {
         r_qtx.lock();
         bool bempty=m_q->empty();
         r_qtx.unlock();
-        if(bempty)
+        if(bempty && isExitWriteData2Disk)
+        {
+            std::cout<<"WriteData2Disk::write2Disk-----------------------队列为空，采集线程已经退出！"<<std::endl;
+            break;
+        }
+        else if(isExitWriteData2Disk)
+        {
+            std::cout<<"WriteData2Disk::write2Disk-----------------------isExitWriteData2Disk：true"<<std::endl;
+            std::cout<<"WriteData2Disk::write2Disk-----------------------队列大小"<<m_q->size()<<std::endl;
+        }
+        else if(bempty && !isExitWriteData2Disk)
         {
-            QThread::msleep(sleepCounters * sleepCounters * 10);
-//            std::cout<<"WriteData2Disk::write2Disk-----------------------队列第几次为空：" << sleepCounters <<std::endl;
-            sleepCounters++;
-
-            if (sleepCounters == 10 && frameCounter != 0)//如果sleepCounters == 10时，队列还是空，就代表相机停止采集 → 退出此线程
-            {
-                break;
-            }
-
             continue;
         }
-        sleepCounters = 1;
+
 
 
         r_qtx.lock();
         DataBuffer * buffer = m_q->front();
-        memcpy(dataBuffer,buffer->data,m_iFrameSizeInByte);
+        int frameNumber = m_qFrameCounter->front();
+        memcpy(dataBuffer,buffer->data,m_iFrameSizeInByte*frameNumber);
 //        m_pool->destroy(m_q->front());
         m_pool->deleteElement(buffer);
         m_q->pop();
+        m_qFrameCounter->pop();
         r_qtx.unlock();
 
         //构造rgb图像，用于推流到m300遥控器
-//        m_rgbImage->FillRgbImage(dataBuffer);
+        m_rgbImage->FillRgbImage(dataBuffer);
 
 
 //        std::cout<<"WriteData2Disk::write2Disk-----------------------正在写磁盘!" << m_pool->max_size() <<std::endl;//
-        fwrite(dataBuffer,1,m_iFrameSizeInByte, hFile);
+        fwrite(dataBuffer,1,m_iFrameSizeInByte*frameNumber, hFile);
+
+
         frameCounter++;
     }
     m_rgbImage->m_VideoWriter.release();
     fclose(hFile);
+    delete[] dataBuffer;
+
 
     std::cout<<"WriteData2Disk::write2Disk-----------------------写磁盘线程将退出，内存池可达到的最多元素数：" << m_pool->max_size() <<std::endl;
-    std::cout<<"WriteData2Disk::write2Disk-----------------------写磁盘线程将退出，共写帧数：" << frameCounter <<std::endl;
+    std::cout<<"WriteData2Disk::write2Disk-----------------------写磁盘线程将退出，fwrite 调用次数：" << frameCounter <<std::endl;
 }
 
-void WriteData2Disk::setParm(queue<DataBuffer *> * q, QString baseFileName, int frameSizeInByte, MemoryPool<DataBuffer> * pool, rgbImage * rgbImage)
+void WriteData2Disk::exitWriteData2Disk()
+{
+    std::cout<< "执行函数：WriteData2Disk::exitWriteData2Disk" <<std::endl;
+    isExitWriteData2Disk = true;
+}
+
+void WriteData2Disk::setParm(queue<DataBuffer *> * q, queue<int> * qFrameCounter, QString baseFileName, int frameSizeInByte, int number_WriteDisk, MemoryPool<DataBuffer> * pool, rgbImage * rgbImage)
 {
     m_q = q;
+    m_qFrameCounter = qFrameCounter;
     m_QbaseFileName = baseFileName;
     m_iFrameSizeInByte = frameSizeInByte;
+    m_iNumber_WriteDisk = number_WriteDisk;
 
     m_pool = pool;
 
     m_rgbImage = rgbImage;
 }
+
+PushFlow::PushFlow()
+{
+    m_iWidth = 1368;
+    m_iHeight = 720;
+    m_iFramerateVideo = 5;
+}
+
+void PushFlow::setParm(rgbImage * img, int width, int height, int framerateVideo)
+{
+    m_rgbImage = img;
+
+    m_iWidth = width;
+    m_iHeight = height;
+    m_iFramerateVideo = framerateVideo;
+}
+
+void PushFlow::setVedioFilePath(QString path)
+{
+    m_QVedioFilePath = path;
+}
+
+void PushFlow::exitPushFlow()
+{
+    isExitPushFlow = true;
+}
+
+void PushFlow::encodePushFlow()
+{
+    // 创建输出视频的AVFormatContext
+    const char* outputVideoPath = "/media/nvme/delete/300tc.h264";
+
+    FILE *fp = fopen(m_QVedioFilePath.toStdString().c_str(),"w+b");
+
+    AVFormatContext* formatContext = nullptr;
+    avformat_alloc_output_context2(&formatContext, nullptr, "mp4", outputVideoPath);
+    if (!formatContext)
+    {
+        qDebug() << "Error: Failed to allocate output context";
+        return;
+    }
+
+    // 查找H.264编码器
+    const AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_H264);
+    if (!codec)
+    {
+        qDebug() << "Error: Codec not found";
+        avformat_free_context(formatContext);
+        return;
+    }
+
+    // 创建输出视频流
+    AVStream* videoStream = avformat_new_stream(formatContext, codec);
+    if (!videoStream)
+    {
+        qDebug() << "Error: Failed to create video stream";
+        avformat_free_context(formatContext);
+        return;
+    }
+    // 设置视频流的参数，例如分辨率、帧率等
+    videoStream->codecpar->width = m_iWidth;
+    videoStream->codecpar->height = m_iHeight;
+    videoStream->codecpar->codec_id = AV_CODEC_ID_H264; // 设置为H.264编解码器
+    videoStream->codecpar->format = AV_PIX_FMT_YUV420P; // 设置为YUV420P像素格式
+
+    // 配置视频流的参数
+    AVCodecContext* codecContext = avcodec_alloc_context3(codec);
+    if (!codecContext)
+    {
+        qDebug() << "Error: Failed to allocate codec context";
+        avformat_free_context(formatContext);
+        return;
+    }
+
+    // 设置视频流的参数，例如分辨率、帧率等
+    codecContext->width = m_iWidth;
+    codecContext->height = m_iHeight;
+    codecContext->time_base = {1, m_iFramerateVideo};
+    codecContext->pix_fmt = AV_PIX_FMT_YUV420P;  // 设置为YUV420P格式
+    codecContext->gop_size = 1;//多少帧产生一组关键帧
+    codecContext->max_b_frames = 1;//b帧，参考帧
+//    codecContext->bit_rate = 1000000; // 设置比特率为 1000000
+
+    // 打开视频编码器
+    if (avcodec_open2(codecContext, codec, nullptr) < 0)
+    {
+        qDebug() << "Error: Failed to open codec";
+        avcodec_free_context(&codecContext);
+        avformat_free_context(formatContext);
+        return;
+    }
+
+    // 打开输出文件
+    if (avio_open(&formatContext->pb, outputVideoPath, AVIO_FLAG_WRITE) < 0)
+    {
+        qDebug() << "Error: Failed to open output file";
+        avcodec_close(codecContext);
+        avcodec_free_context(&codecContext);
+        avformat_free_context(formatContext);
+        return;
+    }
+
+    // 写入文件头
+    avformat_write_header(formatContext, nullptr);
+
+    // 使用sws_scale进行颜色空间转换
+    SwsContext* swsContext = sws_getContext(m_iWidth, m_iHeight, AV_PIX_FMT_BGR24,
+                                            m_iWidth, m_iHeight, AV_PIX_FMT_YUV420P,
+                                            SWS_BICUBIC, nullptr, nullptr, nullptr);
+    if (!swsContext)
+    {
+        qDebug() << "Error: Failed to create sws context";
+        avio_closep(&formatContext->pb);
+        avcodec_close(codecContext);
+        avcodec_free_context(&codecContext);
+        avformat_free_context(formatContext);
+        return;
+    }
+
+    // 创建 AVFrame 作为目标图像
+    AVFrame* dstFrame = av_frame_alloc();
+    av_image_alloc(dstFrame->data, dstFrame->linesize, m_iWidth, m_iHeight, AV_PIX_FMT_YUV420P, 1);
+
+    // 设置目标图像参数
+    dstFrame->width = m_iWidth;
+    dstFrame->height = m_iHeight;
+    dstFrame->format = AV_PIX_FMT_YUV420P;
+
+    AVFrame* frame = av_frame_alloc();
+    av_image_alloc(frame->data, frame->linesize, m_iWidth, m_iHeight, AV_PIX_FMT_BGR24, 1);
+
+    QUdpSocket * m_udpSocket = new QUdpSocket();
+    m_udpSocket->bind(PUSH_FLOW_PORT, QUdpSocket::ShareAddress);
+    QHostAddress m_clientIpAddress=QHostAddress(QHostAddress::LocalHost);
+//    QHostAddress m_clientIpAddress("192.168.1.30");
+//    QHostAddress m_clientIpAddress("192.168.111.1");
+    int udpSendCounter=0;
+    int encodeCounter=0;
+
+    isExitPushFlow = false;
+
+    unsigned long sleepTime = 1/(float)m_iFramerateVideo * 1000;
+    std::cout<< "推流帧率: " << m_iFramerateVideo << ", sleepTime：" << sleepTime << "ms." << std::endl;
+
+    while(true)
+    {
+        QThread::msleep(sleepTime);
+
+        memcpy(frame->data[0], m_rgbImage->m_matRgbImage->data, m_rgbImage->m_matRgbImage->rows * m_rgbImage->m_matRgbImage->step[0]);
+//        memcpy(frame->data[0], m_rgbImage->m_Qphoto.bits(), m_rgbImage->m_Qphoto.byteCount());
+
+        // 使用sws_scale进行颜色空间转换
+        sws_scale(swsContext, frame->data, frame->linesize, 0, m_iHeight,
+                  dstFrame->data, dstFrame->linesize);
+        dstFrame->pts = encodeCounter;
+
+        // 将AVFrame编码为视频帧
+        AVPacket pkt;
+        av_init_packet(&pkt);
+        pkt.data = nullptr;
+        pkt.size = 0;
+
+        if (avcodec_send_frame(codecContext, dstFrame) == 0 &&
+            avcodec_receive_packet(codecContext, &pkt) == 0)
+        {
+            fwrite(pkt.data, 1, pkt.size, fp);
+
+            m_udpSocket->writeDatagram((const char *)pkt.data,pkt.size,m_clientIpAddress, PUSH_FLOW_PORT);
+
+//            std::cout << "编码第 " << udpSendCounter << " 帧数据大小: " << pkt.size << std::endl;
+//            std::cout<< "pkt.pts: " << pkt.pts << std::endl;
+//            std::cout<< "pkt.dts: " << pkt.dts << std::endl << std::endl;
+            udpSendCounter++;
+
+            // 将编码后的帧写入文件
+//            pkt.stream_index = videoStream->index;
+//            av_interleaved_write_frame(formatContext, &pkt);
+//            av_write_frame(formatContext, &pkt);
+
+            av_packet_unref(&pkt);
+        }
+        encodeCounter++;
+
+        if(isExitPushFlow)
+        {
+            std::cout<<"PushFlow::encodePushFlow-----------------------推流线程将退出！"<<std::endl;
+            break;
+        }
+    }
+
+    fclose(fp);
+    // 写入文件尾
+    av_write_trailer(formatContext);
+
+    // 释放AVFrame和相关资源
+    av_freep(&frame->data[0]);
+    av_frame_free(&frame);
+
+    // 释放资源
+    sws_freeContext(swsContext);
+    av_freep(&dstFrame->data[0]);
+    av_frame_free(&dstFrame);
+//    av_packet_free(&pkt);
+    avcodec_close(codecContext);
+    avcodec_free_context(&codecContext);
+    avio_closep(&formatContext->pb);
+    avformat_free_context(formatContext);
+
+    std::cout<<"PushFlow::encodePushFlow-----------------------推流线程已经退出！" << std::endl;
+}