fix：修复时间同步错误

记录上次设置的帧率和曝光时间，打开时，将上次的帧率和曝光时间设置为当前参数；

.gitignore

@@ -1,2 +1,4 @@
 .idea
-build
+build
+/温度测试
+扩展板接口.txt

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5.2)
 project(ximeaAirborneSystem)
 
 set(CMAKE_CXX_STANDARD 14)
@@ -9,7 +9,7 @@ set(CMAKE_AUTOUIC ON)
 set(CMAKE_AUTORCC ON)
 set(CMAKE_CXX_STANDARD 11)
 
-set(QT Core Network SerialPort)
+set(QT Core Network SerialPort Gui)
 set(TEMPLATE app)
 set(TARGET ximeaImageRecorder)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
@@ -17,9 +17,12 @@ find_package(Qt5 REQUIRED ${QT})#
 
 include_directories(.)
 include_directories(/home/300tc/library/ximeaControlDll/Header_Files)
-
 link_directories(/home/300tc/library/ximeaControlDll)
 
+find_package(OpenCV 4.2.0 REQUIRED)
+include_directories(/usr/local/include/opencv4/)
+link_directories(/usr/local/lib)
+
 add_executable(${CMAKE_PROJECT_NAME}
         Source_Files/fileoperation.cpp
         Header_Files/fileoperation.h
@@ -41,10 +44,13 @@ add_executable(${CMAKE_PROJECT_NAME}
         Source_Files/ximeaimager.cpp
         Header_Files/ximeaimager.h
         Source_Files/configfile.cpp
-        Header_Files/configfile.h)
+        Header_Files/configfile.h
+        Header_Files/MemoryPool.tcc
+        Header_Files/MemoryPool.h Source_Files/rgbImage.cpp Header_Files/rgbImage.h)
 qt5_use_modules(${CMAKE_PROJECT_NAME} ${QT})
 
 target_link_libraries(${CMAKE_PROJECT_NAME}
         irisXimeaImager
         libconfig.so
-        libconfig++.so)
+        libconfig++.so
+        ${OpenCV_LIBS})

Header_Files/MemoryPool.h

@@ -0,0 +1,98 @@
+/*-
+ * Copyright (c) 2013 Cosku Acay, http://www.coskuacay.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef MEMORY_POOL_H
+#define MEMORY_POOL_H
+
+#include <climits>
+#include <cstddef>
+
+template <typename T, size_t BlockSize = 409200000>
+class MemoryPool
+{
+  public:
+    /* Member types */
+    typedef T               value_type;
+    typedef T*              pointer;
+    typedef T&              reference;
+    typedef const T*        const_pointer;
+    typedef const T&        const_reference;
+    typedef size_t          size_type;
+    typedef ptrdiff_t       difference_type;
+    typedef std::false_type propagate_on_container_copy_assignment;
+    typedef std::true_type  propagate_on_container_move_assignment;
+    typedef std::true_type  propagate_on_container_swap;
+
+    template <typename U> struct rebind {
+      typedef MemoryPool<U> other;
+    };
+
+    /* Member functions */
+    MemoryPool() noexcept;
+    MemoryPool(const MemoryPool& memoryPool) noexcept;
+    MemoryPool(MemoryPool&& memoryPool) noexcept;
+    template <class U> MemoryPool(const MemoryPool<U>& memoryPool) noexcept;
+
+    ~MemoryPool() noexcept;
+
+    MemoryPool& operator=(const MemoryPool& memoryPool) = delete;
+    MemoryPool& operator=(MemoryPool&& memoryPool) noexcept;
+
+    pointer address(reference x) const noexcept;
+    const_pointer address(const_reference x) const noexcept;
+
+    // Can only allocate one object at a time. n and hint are ignored
+    pointer allocate(size_type n = 1, const_pointer hint = 0);
+    void deallocate(pointer p, size_type n = 1);
+
+    size_type max_size() const noexcept;
+
+    template <class U, class... Args> void construct(U* p, Args&&... args);
+    template <class U> void destroy(U* p);
+
+    template <class... Args> pointer newElement(Args&&... args);
+    void deleteElement(pointer p);
+
+  private:
+    union Slot_ {
+      value_type element;
+      Slot_* next;
+    };
+
+    typedef char* data_pointer_;
+    typedef Slot_ slot_type_;
+    typedef Slot_* slot_pointer_;
+
+    slot_pointer_ currentBlock_;
+    slot_pointer_ currentSlot_;
+    slot_pointer_ lastSlot_;
+    slot_pointer_ freeSlots_;
+
+    size_type padPointer(data_pointer_ p, size_type align) const noexcept;
+    void allocateBlock();
+
+    static_assert(BlockSize >= 2 * sizeof(slot_type_), "BlockSize too small.");
+};
+
+#include "MemoryPool.tcc"
+
+#endif // MEMORY_POOL_H

Header_Files/MemoryPool.tcc

@@ -0,0 +1,235 @@
+/*-
+ * Copyright (c) 2013 Cosku Acay, http://www.coskuacay.com
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef MEMORY_BLOCK_TCC
+#define MEMORY_BLOCK_TCC
+
+
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::size_type
+MemoryPool<T, BlockSize>::padPointer(data_pointer_ p, size_type align)
+const noexcept
+{
+  uintptr_t result = reinterpret_cast<uintptr_t>(p);
+  return ((align - result) % align);
+}
+
+
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool()
+noexcept
+{
+  currentBlock_ = nullptr;
+  currentSlot_ = nullptr;
+  lastSlot_ = nullptr;
+  freeSlots_ = nullptr;
+}
+
+
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool& memoryPool)
+noexcept :
+MemoryPool()
+{}
+
+
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::MemoryPool(MemoryPool&& memoryPool)
+noexcept
+{
+  currentBlock_ = memoryPool.currentBlock_;
+  memoryPool.currentBlock_ = nullptr;
+  currentSlot_ = memoryPool.currentSlot_;
+  lastSlot_ = memoryPool.lastSlot_;
+  freeSlots_ = memoryPool.freeSlots;
+}
+
+
+template <typename T, size_t BlockSize>
+template<class U>
+MemoryPool<T, BlockSize>::MemoryPool(const MemoryPool<U>& memoryPool)
+noexcept :
+MemoryPool()
+{}
+
+
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>&
+MemoryPool<T, BlockSize>::operator=(MemoryPool&& memoryPool)
+noexcept
+{
+  if (this != &memoryPool)
+  {
+    std::swap(currentBlock_, memoryPool.currentBlock_);
+    currentSlot_ = memoryPool.currentSlot_;
+    lastSlot_ = memoryPool.lastSlot_;
+    freeSlots_ = memoryPool.freeSlots;
+  }
+  return *this;
+}
+
+
+
+template <typename T, size_t BlockSize>
+MemoryPool<T, BlockSize>::~MemoryPool()
+noexcept
+{
+  slot_pointer_ curr = currentBlock_;
+  while (curr != nullptr) {
+    slot_pointer_ prev = curr->next;
+    operator delete(reinterpret_cast<void*>(curr));
+    curr = prev;
+  }
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::pointer
+MemoryPool<T, BlockSize>::address(reference x)
+const noexcept
+{
+  return &x;
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::const_pointer
+MemoryPool<T, BlockSize>::address(const_reference x)
+const noexcept
+{
+  return &x;
+}
+
+
+
+template <typename T, size_t BlockSize>
+void
+MemoryPool<T, BlockSize>::allocateBlock()
+{
+  // Allocate space for the new block and store a pointer to the previous one
+  data_pointer_ newBlock = reinterpret_cast<data_pointer_>
+                           (operator new(BlockSize));
+  reinterpret_cast<slot_pointer_>(newBlock)->next = currentBlock_;
+  currentBlock_ = reinterpret_cast<slot_pointer_>(newBlock);
+  // Pad block body to staisfy the alignment requirements for elements
+  data_pointer_ body = newBlock + sizeof(slot_pointer_);
+  size_type bodyPadding = padPointer(body, alignof(slot_type_));
+  currentSlot_ = reinterpret_cast<slot_pointer_>(body + bodyPadding);
+  lastSlot_ = reinterpret_cast<slot_pointer_>
+              (newBlock + BlockSize - sizeof(slot_type_) + 1);
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::pointer
+MemoryPool<T, BlockSize>::allocate(size_type n, const_pointer hint)
+{
+  if (freeSlots_ != nullptr) {
+    pointer result = reinterpret_cast<pointer>(freeSlots_);
+    freeSlots_ = freeSlots_->next;
+    return result;
+  }
+  else {
+    if (currentSlot_ >= lastSlot_)
+      allocateBlock();
+    return reinterpret_cast<pointer>(currentSlot_++);
+  }
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline void
+MemoryPool<T, BlockSize>::deallocate(pointer p, size_type n)
+{
+  if (p != nullptr) {
+    reinterpret_cast<slot_pointer_>(p)->next = freeSlots_;
+    freeSlots_ = reinterpret_cast<slot_pointer_>(p);
+  }
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline typename MemoryPool<T, BlockSize>::size_type
+MemoryPool<T, BlockSize>::max_size()
+const noexcept
+{
+  size_type maxBlocks = -1 / BlockSize;
+  return (BlockSize - sizeof(data_pointer_)) / sizeof(slot_type_) * maxBlocks;
+}
+
+
+
+template <typename T, size_t BlockSize>
+template <class U, class... Args>
+inline void
+MemoryPool<T, BlockSize>::construct(U* p, Args&&... args)
+{
+  new (p) U (std::forward<Args>(args)...);
+}
+
+
+
+template <typename T, size_t BlockSize>
+template <class U>
+inline void
+MemoryPool<T, BlockSize>::destroy(U* p)
+{
+  p->~U();
+}
+
+
+
+template <typename T, size_t BlockSize>
+template <class... Args>
+inline typename MemoryPool<T, BlockSize>::pointer
+MemoryPool<T, BlockSize>::newElement(Args&&... args)
+{
+  pointer result = allocate();
+  construct<value_type>(result, std::forward<Args>(args)...);
+  return result;
+}
+
+
+
+template <typename T, size_t BlockSize>
+inline void
+MemoryPool<T, BlockSize>::deleteElement(pointer p)
+{
+  if (p != nullptr) {
+    p->~value_type();
+    deallocate(p);
+  }
+}
+
+
+
+#endif // MEMORY_BLOCK_TCC

Header_Files/configfile.h

@@ -9,9 +9,14 @@
 #include <iomanip>
 #include <cstdlib>
 #include <libconfig.h++>
+#include <string>
 
 #include <QFileInfo>
 #include <QString>
+#include <QCoreApplication>
+#include <QDir>
+
+#include "utility_tc.h"
 
 using namespace std;
 using namespace libconfig;
@@ -25,14 +30,44 @@ public:
     bool isConfigfileExist();
     bool parseConfigfile();
 
-    bool getBin(int &bin);
+    bool getSpectralBin(int &spectralBin);
+    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 createConfigFile();
     bool updateConfigFile();
 
+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();
+
 private:
     string m_configfilePath;
     Config cfg;

Header_Files/rgbImage.h

@@ -0,0 +1,75 @@
+//
+// Created by tangchao on 2022/12/24.
+//
+
+#ifndef XIMEAAIRBORNESYSTEM_RGBIMAGE_H
+#define XIMEAAIRBORNESYSTEM_RGBIMAGE_H
+
+#include <iostream>
+#include <string>
+
+#include <QObject>
+#include <QImage>
+#include <opencv2/opencv.hpp>//包含了所有东西，编译很慢
+
+using namespace cv;
+class rgbImage :public QObject
+{
+
+Q_OBJECT
+public:
+    rgbImage(QWidget* pParent = NULL);
+    ~rgbImage();
+
+    void SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNumber);
+    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 *m_QRgbImage;
+    cv::Mat *m_matRgbImage;
+
+    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:
+    int m_iSampleNumber;//
+    int m_iBandNumber;//
+
+    int m_iFrameNumber;//
+
+public slots:
+
+signals :
+    void sendstr(QString str);
+    void sendstr1(QString str);
+    void refreslabelimg(QImage* img1);
+
+
+};
+
+
+#endif //XIMEAAIRBORNESYSTEM_RGBIMAGE_H

Header_Files/sbgrecorder.h

@@ -69,8 +69,7 @@ namespace sbgtc
 
         void sbgSolutionModeSignal(int);
 
-        void sbgAccuracySignal(int);
-
+        void sbgAccuracySignal(int, int);
     };
 
 }

Header_Files/udpserver.h

@@ -63,9 +63,12 @@ public slots:
     void sendSerialPortStatus(int serialPortStatus);
 
     void sendSbgSolutionModeState(int SolutionMode);
-    void sendSbgAccuracyState(int Accuracy);
+    void sendSbgAccuracyState(int Accuracy,int SatelliteCounter);
 
     void sendXimeaImageStatus(int ximeaImageStatus);
+    void sendXimeaAutoExposeMaxValueOfOneFrame(int autoExposeMaxValueOfOneFrame, double exposeTime);
+    void sendXimeaBinState(int spatialBin, int spectralBin);
+    void sendXimeaImageFrameRate(double frameRate);
     void sendCopyFileStatus(int fileStatus);
 };
 #endif // UDPSERVER_H

Header_Files/utility_tc.h

@@ -2,15 +2,22 @@
 #define UTILITY_TC_H
 
 #include <iostream>
+#include <ctime>
 
 #include <QString>
 #include <QDebug>
 
 QString getFileNameBaseOnTime();
 
+QString formatTimeStr(char * format);
+
 //https://blog.csdn.net/MoreWindows/article/details/6657829
 void bubbleSort(unsigned short * a, int n);
 
 void swap(unsigned short * a, unsigned short * b);
 
+bool createDir(QString fullPath);
+
+QList<QString> getFileInfo(QString file);
+
 #endif // UTILITY_TC_H

Header_Files/ximeaimager.h

@@ -25,10 +25,13 @@
 #include <fstream>
 #include <unistd.h>
 #include <exception>
+#include <fcntl.h>
+#include <sys/mman.h>
 
 #include <QObject>
 #include <QDateTime>
 #include <qthread.h>
+#include <QDir>
 
 #include "configfile.h"
 
@@ -36,6 +39,13 @@
 #include "math.h"
 #include "utility_tc.h"
 
+#include "MemoryPool.h"
+#include <queue>
+#include <QMutex>
+
+#include "rgbImage.h"
+
+
 
 //#ifdef WIN32
 //#include <xiApi.h>       // Windows
@@ -43,12 +53,30 @@
 //#include <m3api/xiApi.h> // Linux, OSX
 //#endif
 
+//struct DataBuffer
+//{
+//    unsigned short data[409200/2];
+//};
+
+class DataBuffer
+{
+public:
+    DataBuffer();
+    ~DataBuffer();
+
+    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();
 
@@ -56,6 +84,7 @@ private:
     Iris::IrisXimeaImager * m_imager;
 
     bool m_bIsRecord;
+    XimeaImager * m_ximeaImager;
 public slots:
     void recordTemperature(QString filePath);
 
@@ -63,16 +92,48 @@ signals:
 
 };
 
+//queue<DataBuffer *> q;
+//static QMutex r_qtx{ QMutex::Recursive };
+static std::mutex r_qtx;
+
+class WriteData2Disk : public QObject
+{
+Q_OBJECT
+
+public:
+    WriteData2Disk();
+    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 XimeaImager : public QObject
 {
     Q_OBJECT
 
 public:
     XimeaImager();
+    ~XimeaImager();
 
     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();
     void setGain(double gain);
@@ -86,6 +147,7 @@ public:
 
     void stopRecord();
     int getFrameCounter();
+    void writeXiApiErrorCodes(QString filePath, int xiApiErrorCodes);
 
     int getMaxValueOfOneFrame(unsigned short * data, int numberOfPixel);
 
@@ -95,46 +157,48 @@ 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;
+
     QString m_baseFileName;
     QString m_ximeaTemperatureCSVPath;
 
     Iris::IrisXimeaImager m_imager;
     unsigned short * m_buffer;
+//    MemoryPool<unsigned short> m_pool;
     bool m_bRecordControl;
     int m_iFrameCounter;
     int m_iFrameSizeInByte;
+    rgbImage * m_rgbImage;
     void writeHdr();
 
     void processXiApiErrorCodes(int xiApiErrorCodes);
 
-    inline double getSbgTime(double TimeDifferenceBetweensOSAndSbg)
+    inline double getSbgTime(XI_IMG * image, double timeDifferenceBetweenSbgAndXimea)
     {
-        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 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;
+        double ximeaTime = (double)image->tsSec + (double)image->tsUSec/1000000;
+        return ximeaTime + timeDifferenceBetweenSbgAndXimea;
     }
 
     Configfile m_configfile;
+    ParameterConfigfile m_parameterConfigfile;
+
+
 
 public slots:
     void openImger();
     void closeImger();
 
+    double calculateTimeDifferenceBetweenSbgAndximea(XI_IMG * m_image, double timeDifferenceBetweenSbgAndOS);
     void startRecord(double TimeDifferenceBetweensOSAndSbg,QString baseFileName);
 
 signals:
@@ -142,5 +206,10 @@ signals:
     void ximeaImageStatus(int);
 
     void recordXimeaTemperatureSignal(QString);
+    void startWriteDiskSignal();
+
+    void autoExposeMaxValueOfOneFrame(int, double);
+    void frameRateSignal(double);
+    void binSignal(int, int);
 };
 #endif // XIMEAIMAGER_H

Source_Files/configfile.cpp

@@ -43,17 +43,32 @@ bool Configfile::parseConfigfile()
     }
 }
 
-bool Configfile::getBin(int &bin)
+bool Configfile::getSpectralBin(int &spectralBin)
 {
     try
     {
-        bin = cfg.lookup("bin");
+        spectralBin = cfg.lookup("spectralBin");
 
         return true;
     }
     catch(const SettingNotFoundException &nfex)
     {
-        cerr << "No 'bin' setting in configuration file." << endl;
+        cerr << "No 'spectralBin' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+bool Configfile::getspatialBin(int &spatialBin)
+{
+    try
+    {
+        spatialBin = cfg.lookup("spatialBin");
+
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'spatialBin' setting in configuration file." << endl;
         return false;
     }
 }
@@ -62,22 +77,41 @@ bool Configfile::getEffectiveWindow(int &width, int &offsetx, int &height, int &
 {
     const Setting& root = cfg.getRoot();
 
-    // Output a list of all books in the inventory.
     try
     {
-        const Setting &effective_window = root["effective_window"];
-        int count = effective_window.getLength();
+        int spatialBin;
+        int spectralBin;
+        getspatialBin(spatialBin);
+        getSpectralBin(spectralBin);
 
-        int bin;
-        getBin(bin);
+        string spatialBinString;
+        if(spatialBin == 1)
+        {
+            spatialBinString = "bin1";
+        }
+        else
+        {
+            spatialBinString = "bin2";
+        }
+        const Setting &spatialArgument = root["effective_window"][spatialBinString]["spatial"];
+        if(!(spatialArgument.lookupValue("width", width)
+             && spatialArgument.lookupValue("offsetx", offsetx)))
+        {
+            return false;
+        }
 
-        const Setting &window = effective_window[bin-1];
-        string name = window.getName();
-
-        if(!(window.lookupValue("width", width)
-             && window.lookupValue("offsetx", offsetx)
-             && window.lookupValue("height", height)
-             && window.lookupValue("offsety", offsety)))
+        string spectralBinString;
+        if(spectralBin == 1)
+        {
+            spectralBinString = "bin1";
+        }
+        else
+        {
+            spectralBinString = "bin2";
+        }
+        const Setting &spectralArgument = root["effective_window"][spectralBinString]["spectral"];
+        if(!(spectralArgument.lookupValue("height", height)
+             && spectralArgument.lookupValue("offsety", offsety)))
         {
             return false;
         }
@@ -95,16 +129,25 @@ bool Configfile::getEffectiveWindowRoi(int &width, int &offsetx)
 {
     const Setting& root = cfg.getRoot();
 
-    // Output a list of all books in the inventory.
     try
     {
         const Setting &effective_window = root["effective_window_roi"];
         int count = effective_window.getLength();
 
-        int bin;
-        getBin(bin);
+        int spatialBin;
+        getspatialBin(spatialBin);
 
-        const Setting &window = effective_window[bin-1];
+        string spatialBinString;
+        if(spatialBin == 1)
+        {
+            spatialBinString = "spatialBin1";
+        }
+        else
+        {
+            spatialBinString = "spatialBin2";
+        }
+
+        const Setting &window = effective_window[spatialBinString];
         string name = window.getName();
 
         if(!(window.lookupValue("width", width)
@@ -123,20 +166,51 @@ bool Configfile::getEffectiveWindowRoi(int &width, int &offsetx)
     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();
 
-    // Output a list of all books in the inventory.
     try
     {
         const Setting &gainOffset = root["gainOffset"];
         int count = gainOffset.getLength();
 
-        int bin;
-        getBin(bin);
+        int spectralBin;
+        getSpectralBin(spectralBin);
 
-        const Setting &gainOffsetSetting = gainOffset[bin-1];
+        string spectralBinString;
+        if(spectralBin == 1)
+        {
+            spectralBinString = "spectralBin1";
+        }
+        else
+        {
+            spectralBinString = "spectralBin2";
+        }
+
+        const Setting &gainOffsetSetting = gainOffset[spectralBinString];
         string name = gainOffsetSetting.getName();
 
         if(!(gainOffsetSetting.lookupValue("gain", gain)
@@ -154,69 +228,171 @@ 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
+    {
+        std::string SN_tem = cfg.lookup("SN");
+        SN = QString::fromStdString(SN_tem);
+
+        return true;
+    }
+    catch(const SettingNotFoundException &nfex)
+    {
+        cerr << "No 'spectralBin' setting in configuration file." << endl;
+        return false;
+    }
+}
+
+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;
     using namespace libconfig;
 
-    static const char *output_file = "ximea.cfg";
     Config cfg;
 
     Setting &root = cfg.getRoot();
 
     // Add some settings to the configuration.
-    Setting &bin = root.add("bin", Setting::TypeInt) = 1;
     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 &effective_window = root.add("effective_window", Setting::TypeGroup);
     Setting &effective_window_Bin1 = effective_window.add("bin1", Setting::TypeGroup);
+    Setting &effective_window_Bin1_spatial = effective_window_Bin1.add("spatial", Setting::TypeGroup);
+    Setting &effective_window_Bin1_Spectral = effective_window_Bin1.add("spectral", Setting::TypeGroup);
     Setting &effective_window_Bin2 = effective_window.add("bin2", Setting::TypeGroup);
+    Setting &effective_window_Bin2_spatial = effective_window_Bin2.add("spatial", Setting::TypeGroup);
+    Setting &effective_window_Bin2_Spectral = effective_window_Bin2.add("spectral", Setting::TypeGroup);
 
-    effective_window_Bin1.add("width", Setting::TypeInt) = 1392;
-    effective_window_Bin1.add("offsetx", Setting::TypeInt) = 272;
-    effective_window_Bin1.add("height", Setting::TypeInt) = 300;
-    effective_window_Bin1.add("offsety", Setting::TypeInt) = 348;
+    effective_window_Bin1_spatial.add("width", Setting::TypeInt) = 1368;
+    effective_window_Bin1_spatial.add("offsetx", Setting::TypeInt) = 288;
+    effective_window_Bin1_Spectral.add("height", Setting::TypeInt) = 300;
+    effective_window_Bin1_Spectral.add("offsety", Setting::TypeInt) = 348;
 
-    effective_window_Bin2.add("width", Setting::TypeInt) = 712;
-    effective_window_Bin2.add("offsetx", Setting::TypeInt) = 128;
-    effective_window_Bin2.add("height", Setting::TypeInt) = 151;
-    effective_window_Bin2.add("offsety", Setting::TypeInt) = 174;
+    effective_window_Bin2_spatial.add("width", Setting::TypeInt) = 688;
+    effective_window_Bin2_spatial.add("offsetx", Setting::TypeInt) = 144;
+    effective_window_Bin2_Spectral.add("height", Setting::TypeInt) = 150;
+    effective_window_Bin2_Spectral.add("offsety", Setting::TypeInt) = 174;
 
     Setting &effective_window_roi = root.add("effective_window_roi", Setting::TypeGroup);
-    Setting &effective_window_roi_Bin1 = effective_window_roi.add("bin1", Setting::TypeGroup);
-    Setting &effective_window_roi_Bin2 = effective_window_roi.add("bin2", Setting::TypeGroup);
+    Setting &effective_window_roi_spatialBin1 = effective_window_roi.add("spatialBin1", Setting::TypeGroup);
+    Setting &effective_window_roi_spatialBin2 = effective_window_roi.add("spatialBin2", Setting::TypeGroup);
 
-    effective_window_roi_Bin1.add("width", Setting::TypeInt) = 1364;
-    effective_window_roi_Bin1.add("offsetx", Setting::TypeInt) = 14;
+    effective_window_roi_spatialBin1.add("width", Setting::TypeInt) = 1364;
+    effective_window_roi_spatialBin1.add("offsetx", Setting::TypeInt) = 14;
 //    effective_window_roi_Bin1.add("height", Setting::TypeInt) = 300;
 //    effective_window_roi_Bin1.add("offsety", Setting::TypeInt) = 348;
 
-    effective_window_roi_Bin2.add("width", Setting::TypeInt) = 682;
-    effective_window_roi_Bin2.add("offsetx", Setting::TypeInt) = 15;
+    effective_window_roi_spatialBin2.add("width", Setting::TypeInt) = 682;
+    effective_window_roi_spatialBin2.add("offsetx", Setting::TypeInt) = 15;
 //    effective_window_roi_Bin2.add("height", Setting::TypeInt) = 151;
 //    effective_window_roi_Bin2.add("offsety", Setting::TypeInt) = 174;
 
     Setting &gainOffset = root.add("gainOffset", Setting::TypeGroup);
-    Setting &gainOffsetBin1 = gainOffset.add("bin1", Setting::TypeGroup);
-    Setting &gainOffsetBin2 = gainOffset.add("bin2", Setting::TypeGroup);
+    Setting &gainOffsetSpectralBin1 = gainOffset.add("spectralBin1", Setting::TypeGroup);
+    Setting &gainOffsetSpectralBin2 = gainOffset.add("spectralBin2", Setting::TypeGroup);
 
-    gainOffsetBin1.add("gain", Setting::TypeFloat) = 2.00313433;
-    gainOffsetBin1.add("offset", Setting::TypeFloat) = -300.46283157590585;
+    gainOffsetSpectralBin1.add("gain", Setting::TypeFloat) = 2.00313433;
+    gainOffsetSpectralBin1.add("offset", Setting::TypeFloat) = -300.46283157590585;
 
-    gainOffsetBin2.add("gain", Setting::TypeFloat) = 4.00626868;
-    gainOffsetBin2.add("offset", Setting::TypeFloat) = -299.46126663407176;
+    gainOffsetSpectralBin2.add("gain", Setting::TypeFloat) = 4.00626868;
+    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
     {
-        cfg.writeFile(output_file);
-        cerr << "New configuration successfully written to: " << output_file << endl;
+        QList<QString> fileInfo = getFileInfo(output_file);
+        bool ret = createDir(fileInfo[0]);
+
+        cfg.writeFile(output_file.toStdString().c_str());
+        cerr << "New configuration successfully written to: " << output_file.toStdString().c_str() << endl;
 
     }
     catch(const FileIOException &fioex)
     {
-        cerr << "I/O error while writing configuration file: " << output_file << endl;
+        cerr << "I/O error while writing configuration file: " << output_file.toStdString().c_str() << endl;
         return true;
     }
 
@@ -292,3 +468,172 @@ 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 << "----------------"<< 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 << "----------------"<< 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;
+}

Source_Files/main.cpp

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

Source_Files/rgbImage.cpp

@@ -0,0 +1,253 @@
+//
+// Created by tangchao on 2022/12/24.
+//
+
+#include "../Header_Files/rgbImage.h"
+
+
+rgbImage::rgbImage(QWidget* pParent)
+{
+    m_QRgbImage = nullptr;
+    m_matRgbImage = nullptr;
+    m_matFocusGrayImage = nullptr;
+    m_qimageFocusGrayImage = nullptr;
+
+
+
+}
+
+rgbImage::~rgbImage()
+{
+
+}
+
+
+void rgbImage::SetRgbImageWidthAndHeight(int BandCount, int Sample, int FrameNumber)
+{
+    using namespace cv;
+
+    if (m_QRgbImage != nullptr)
+    {
+        delete m_QRgbImage;//有问题？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？
+    }
+    //m_QRgbImage = new QImage(Sample, FrameNumber, QImage::Format_RGB888);
+
+
+    if (m_matRgbImage != nullptr)
+    {
+        delete m_matRgbImage;
+    }
+    m_matRgbImage = new Mat(FrameNumber, Sample, CV_8UC3, Scalar(0, 0, 0));
+
+    int codec = VideoWriter::fourcc('M', 'P', '4', '2');  // select desired codec (must be available at runtime)
+    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
+    m_VideoWriter.open(filename, codec, fps, m_matRgbImage->size(), true);
+
+//    VideoWriter video("test.avi", CV_FOURCC('M', 'J', 'P', 'G'), 25.0, Size(640, 480));
+
+//    m_frame_writer = cvCreateVideoWriter("/media/nvme/delete/live.avi",  cv::VideoWriter::fourcc('M', 'J', 'P', 'G'), 20.0, Size(688, 688), false);
+
+
+
+
+
+    if (m_qimageFocusGrayImage == nullptr)
+    {
+        m_qimageFocusGrayImage = new QImage(Sample, BandCount, QImage::Format_RGB32);
+    }
+
+
+    if (m_matFocusGrayImage == nullptr)
+    {
+        m_matFocusGrayImage = new Mat(BandCount, Sample, CV_16U, Scalar(0));
+
+        //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Sample, CV_16U);
+    }
+
+    //cv::Mat matAdjustPreview = Mat::zeros(BandCount, Sample, CV_16U);
+    //m_matFocusGrayImage = matAdjustPreview;
+
+
+
+
+
+
+
+
+    std::cout << "设置帧数：" << FrameNumber << std::endl;
+
+    m_iFrameCounter = 0;//每次都重置为0
+    m_iSampleNumber = Sample;
+    m_iBandNumber = BandCount;
+    m_iFrameNumber = FrameNumber;
+
+    //std::cout << "rgb影像内存地址为：" << m_QRgbImage << std::endl;
+}
+
+void rgbImage::FillOnerowofRgbImage(cv::Mat * matRgbImage, int rowNumber, unsigned short *datacube)
+{
+    unsigned short r, g, b;
+    for (int j = 0; j < m_iSampleNumber; j++)
+    {
+        //取值：一帧影像中，从左到右的rgb像元值
+        r = *(datacube + 121 * m_iSampleNumber + j)*255/4096;
+        g = *(datacube + 79 * m_iSampleNumber + j)*255/4096;
+        b = *(datacube + 40 * m_iSampleNumber + j)*255/4096;
+
+        //将像元值赋值到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_16UC3)
+        {
+            //std::cout << "操作像素值！" << std::endl;
+            matRgbImage->at<cv::Vec3w>(rowNumber, j)[2] = r;
+            matRgbImage->at<cv::Vec3w>(rowNumber, j)[1] = g;
+            matRgbImage->at<cv::Vec3w>(rowNumber, j)[0] = b;
+        }
+    }
+}
+
+void rgbImage::FillRgbImage(unsigned short *datacube)
+{
+    unsigned short *r_row, *g_row, *b_row;
+
+    if(m_iFrameCounter<m_iFrameNumber)
+    {
+        FillOnerowofRgbImage(m_matRgbImage, m_iFrameCounter, datacube);
+//        std::cout << "小于：" << m_iFrameNumber << std::endl;
+    }
+    else
+    {
+//        std::cout << "大于：" << m_iFrameNumber << std::endl;
+
+        //通过行赋值将前m_iFrameNumber-1行向上移动一行，https://blog.csdn.net/u014686356/article/details/65937750
+//        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;
+        }
+
+
+//        std::cout << "1111111111111111111111111111"<< std::endl;
+        //通过FillOnerowofRgbImage为m_iFrameNumber行赋值
+        FillOnerowofRgbImage(m_matRgbImage, m_iFrameNumber-1, datacube);
+//        std::cout << "22222222222222222"<< std::endl;
+
+
+
+
+
+//        //循环给每行像素赋值
+//        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]];
+//            }
+//
+//        }
+
+
+
+        //保存rgb图片
+        if (m_iFrameCounter % m_iFramerate == 0 || m_iFrameCounter == m_iFrameNumber - 1)
+        {
+            ////保存文件
+            //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++;
+}
+
+void rgbImage::FillFocusGrayImage(unsigned short * datacube)
+{
+    int rowCount = m_matFocusGrayImage->rows;
+    int colCount = m_matFocusGrayImage->cols;
+    for (unsigned short i = 0; i < m_matFocusGrayImage->rows; i++)
+    {
+        for (unsigned short j = 0; j < m_matFocusGrayImage->cols; j++)
+        {
+            //m_matFocusGrayImage->at<ushort>(i, j) = *(datacube + m_matFocusGrayImage->cols*i + j);
+            m_matFocusGrayImage->at<ushort>(i, j) = datacube[m_matFocusGrayImage->cols*i + j];
+        }
+    }
+
+
+
+    //int rowCount = m_matFocusGrayImage.rows;
+    //int colCount = m_matFocusGrayImage.cols;
+    ////memcpy(m_matFocusGrayImage.data, datacube, rowCount*colCount);
+    //for (unsigned short i = 0; i < m_matFocusGrayImage.rows; i++)
+    //{
+    //	for (unsigned short j = 0; j < m_matFocusGrayImage.cols; j++)
+    //	{
+    //		m_matFocusGrayImage.at<ushort>(i, j) = *(datacube + m_matFocusGrayImage.cols*i + j);
+    //		//m_matFocusGrayImage.at<ushort>(i, j) = datacube[colCount*i + j];
+    //	}
+    //}
+
+    //将mat保存成文件
+    //cv::imwrite("D:/delete/2222222222/test.bmp", m_matFocusGrayImage);
+}
+
+void rgbImage::FillFocusGrayQImage(unsigned short * datacube)
+{
+    float two_eight = pow(2.0, 8);
+    float two_sixteen = pow(2.0, 12);
+
+    int width = m_qimageFocusGrayImage->width();
+    int height = m_qimageFocusGrayImage->height();
+    for (unsigned short i = 0; i < height; i++)
+    {
+        for (unsigned short j = 0; j < width; j++)
+        {
+            //uint tmp = (two_eight* *(datacube + width * i + j)) / two_sixteen;
+            uint tmp = (two_eight* datacube[width*i + j]) / two_sixteen;
+            //uint tmp = datacube[width*i + j];
+
+
+            //m_qimageFocusGrayImage->setPixel(j, i, tmp);
+            m_qimageFocusGrayImage->setPixel(j, i, qRgb((unsigned char)tmp, (unsigned char)tmp, (unsigned char)tmp));
+        }
+    }
+
+    m_qimageFocusGrayImage->save("D:/delete/2222222222/test.bmp");
+
+
+
+
+    /*float two_eight = pow(2.0, 8);
+    float two_sixteen = pow(2.0, 16);
+    QImage *qi = new QImage(imwidth, imheight, QImage::Format_RGB32);
+    for (int i = 0; i < imheight; i++)
+    {
+        for (int j = 0; j < imwidth; j++)
+        {
+            floatData[i*imwidth + j] = (two_eight* floatData[i*imwidth + j]) / two_sixteen;
+            qi->setPixel(j, i, qRgb((unsigned char)floatData[i*imwidth + j], (unsigned char)floatData[i*imwidth + j], (unsigned char)floatData[i*imwidth + j]));
+
+
+        }
+    }*/
+
+}

Source_Files/sbgrecorder.cpp

@@ -53,7 +53,7 @@ void sbgtc::SbgRecorder::openSerialPort()
     }
 
 //    QString portname = "sbg_serial_port";
-    QString portname = "ttyS4";
+    QString portname = "ttyUSB0";
 
     m_serial->setPortName(portname);
     m_serial->open(QIODevice::ReadWrite);
@@ -608,76 +608,51 @@ 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;//这是错的
+        uint32_t mode=status & 0xf;
 
         //一秒钟发射一次mode
         if(m_iSolutionModeCounter%200 == 0)
         {
             emit sbgSolutionModeSignal(mode);
+//            std::cout << "logData.ekfEulerData.status: " << status << std::endl;
 
-            switch (mode)
-            {
-            case SBG_ECOM_SOL_MODE_UNINITIALIZED:
-                std::cout<<"此刻模式为: "<<"UNINITIALIZED"<<std::endl;
-                break;
-            case SBG_ECOM_SOL_MODE_VERTICAL_GYRO:
-                std::cout<<"此刻模式为: "<<"VERTICAL_GYRO"<<std::endl;
-                break;
-            case SBG_ECOM_SOL_MODE_AHRS:
-                std::cout<<"此刻模式为: "<<"AHRS"<<std::endl;
-                break;
-            case SBG_ECOM_SOL_MODE_NAV_VELOCITY:
-                std::cout<<"此刻模式为: "<<"NAV_VELOCITY"<<std::endl;
-                break;
-            case SBG_ECOM_SOL_MODE_NAV_POSITION:
-                std::cout<<"此刻模式为: "<<"NAV_POSITION"<<std::endl;
+            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;
+                    break;
+                default:
+                    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)
     {
-//        std::cout<<"纬度精度为："<<logData.gpsPosData.latitudeAccuracy<<std::endl;
-
         float maximal=0;
         float latitudeAccuracy=logData.gpsPosData.latitudeAccuracy;
         float longitudeAccuracy=logData.gpsPosData.longitudeAccuracy;
         float altitudeAccuracy=logData.gpsPosData.altitudeAccuracy;
-
+        int satelliteCounter=(int)logData.gpsPosData.numSvUsed;
 
         if(latitudeAccuracy<longitudeAccuracy)
             maximal = longitudeAccuracy;
@@ -687,7 +662,14 @@ void sbgtc::SbgRecorder::parseSbgMessage(QByteArray * sbgMessage)
         if(maximal<altitudeAccuracy)
             maximal = altitudeAccuracy;
 
-        emit sbgAccuracySignal(static_cast<int>(maximal));
+//        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);
 
         if(maximal<7)
         {
@@ -710,15 +692,10 @@ void sbgtc::SbgRecorder::parseSbgMessage(QByteArray * sbgMessage)
         char setGpsTimeCommand[256];
         sprintf(setGpsTimeCommand,"date --set=\"%d%02d%02d %02d:%02d:%02d\"",year,month,day,hour,minute,second);//02中的2代表2位数字，0代表以0补全
 
-        system(setGpsTimeCommand);//
+//        system(setGpsTimeCommand);
 
         m_bIsSyncSystemTimeBaseGpstime=true;
     }
-    else if(receivedMsgClass==SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_EKF_EULER)
-    {
-//        std::cout<<"1111111111111"<<"UTC time:"<<(int)logData.utcData.year<<","<<(int)logData.utcData.month<<","<<(int)logData.utcData.day<<","<<(int)logData.utcData.hour<<","<<(int)logData.utcData.minute<<","<<(int)(int)logData.utcData.second<<std::endl;
-//        std::cout<<"receivedMsg:"<<(int)receivedMsg<<std::endl;
-    }
     else if(receivedMsgClass!=SBG_ECOM_CLASS_LOG_ECOM_0 && receivedMsg==SBG_ECOM_LOG_EKF_QUAT)
     {
         //std::cout<<"1111111111111------"<<"UTC time:"<<(int)logData.utcData.year<<","<<(int)logData.utcData.month<<","<<(int)logData.utcData.day<<","<<(int)logData.utcData.hour<<","<<(int)logData.utcData.minute<<","<<(int)(int)logData.utcData.second<<std::endl;
@@ -731,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);
@@ -793,7 +770,7 @@ void sbgtc::SbgRecorder::startRecordSbg()
 
     m_baseFileName=getFileNameBaseOnTime();
 
-    QString sbgFileName=m_baseFileName+".sbg";
+    QString sbgFileName=m_baseFileName+".bin";
 
     FILE * fileHandle=fopen(sbgFileName.toStdString().c_str(),"w+b");
 
@@ -802,7 +779,7 @@ void sbgtc::SbgRecorder::startRecordSbg()
     while (m_bRecordControl)
     {
         //std::cout<<"SbgRecorder::startRecordSbg--------------:"<<std::endl;
-        if(m_serial->waitForReadyRead())
+        if(m_serial->waitForReadyRead(30000))
         {
             //requestData.resize(m_serial->size());
             requestData = m_serial->readAll();

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_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_RecordThread=new QThread();
-    m_imager=new XimeaImager();
-    m_imager->moveToThread(m_RecordThread);
-    m_RecordThread->start();
-
     m_CopyFileThread=new QThread();
     m_copyFile=new FileOperation();
     m_copyFile->moveToThread(m_CopyFileThread);
@@ -47,9 +47,12 @@ UdpServer::UdpServer()
     connect(m_sbgRecorder, SIGNAL(serialPortStatus(int)),this, SLOT(sendSerialPortStatus(int)));
 
     connect(m_sbgRecorder, SIGNAL(sbgSolutionModeSignal(int)),this, SLOT(sendSbgSolutionModeState(int)));
-    connect(m_sbgRecorder, SIGNAL(sbgAccuracySignal(int)),this, SLOT(sendSbgAccuracyState(int)));
+    connect(m_sbgRecorder, SIGNAL(sbgAccuracySignal(int,int)),this, SLOT(sendSbgAccuracyState(int,int)));
 
     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)));
 
 
@@ -57,10 +60,10 @@ UdpServer::UdpServer()
     //当软件不正常关闭并且重启后，通知其他psdk程序
     m_clientIpAddress=QHostAddress(QHostAddress::LocalHost);
     sendSerialPortStatus(0);
-    sendXimeaImageStatus(0);
+    sendXimeaImageStatus(100);
     sendCopyFileStatus(0);
 
-
+    system("sudo gpio write 10 0");
 
 
     std::cout<<"UdpServer::UdpServer--------:System ready!"<<std::endl;
@@ -88,6 +91,10 @@ void UdpServer::processPendingDatagrams()
         case 1://启动系统: 打开sbg串口并采集数据，打开光谱仪
         {
             std::cout<<"1代表启动系统!"<<std::endl;
+
+            system("sudo gpio write 10 1");
+            sleep(4);//睡眠4秒，等待电脑打开usb电源，以便给相机供电
+
             emit systemStart();
 
             break;
@@ -110,31 +117,27 @@ void UdpServer::processPendingDatagrams()
 
             emit systemStop();
 
+            sleep(4);//睡眠4秒，等待
+            system("sudo gpio write 10 0");
+
             //QCoreApplication::quit();
             break;
         }
         case 3://系统开始采集高光谱影像
         {
-            //emit startRecordHyperspectralSignal();//真实的影像开始采集通过惯导中的信号(sbgReady)触发
-            m_sbgRecorder->startRecordHyperspectral();
-
-//            if(m_sbgRecorder->getSbgState()==2)//开始采集前还需要判断相机的状态??????????????????????????????????????????
-//            {
-
-//            }
-//            else if(m_sbgRecorder->getSbgState()==3)
-//            {
-//                std::cout<<"系统已经开始采集!"<<std::endl;
-//            }
+            if(m_imager->getImagerState()>=101 && m_imager->getImagerState()<=103)
+            {
+                std::cout<<"3代表系统开始采集高光谱影像!"<<std::endl;
+                m_sbgRecorder->startRecordHyperspectral();
+            }
 
             break;
         }
         case 4://系统停止采集高光谱影像
         {
-            std::cout<<"4代表系统停止采集高光谱影像!"<<std::endl;
-
             if(m_imager->getImagerState()>=101 && m_imager->getImagerState()<=104)
             {
+                std::cout<<"4代表系统停止采集高光谱影像!"<<std::endl;
                 m_imager->stopRecord();
             }
 
@@ -162,17 +165,11 @@ void UdpServer::processPendingDatagrams()
         }
         case 7:
         {
-            if(datagramList[1].toInt()==1)
+            if(m_imager->getImagerState()>=101 && m_imager->getImagerState()<=103)
             {
-                std::cout<<"拷贝数据!"<<std::endl;
-
-                emit startCopyFileSignal();
-            }
-            else if(datagramList[1].toInt()==0)
-            {
-                std::cout<<"删除数据!"<<std::endl;
-
-                emit startDeleteFileSignal();
+                float time = datagramList[1].toFloat();//ms
+                m_imager->wrapSetExposureTime(time*1000);
+                std::cout<<"7，手动设置曝光时间为：" << time <<std::endl;
             }
 
             break;
@@ -253,9 +250,9 @@ void UdpServer::sender(int status)
 
 void UdpServer::sendSerialPortStatus(int serialPortStatus)
 {
-    std::cout<<"UdpServer::sendSerialPortStatus---------------------:"<< serialPortStatus <<std::endl;
+//    std::cout<<"UdpServer::sendSerialPortStatus---------------------:"<< serialPortStatus <<std::endl;
 
-    std::cout<<"UdpServer::sendSerialPortStatus---------------------:"<< m_clientIpAddress.AnyIPv4 <<std::endl;
+//    std::cout<<"UdpServer::sendSerialPortStatus---------------------:"<< m_clientIpAddress.AnyIPv4 <<std::endl;
 
     QByteArray datagram2send;
 
@@ -267,7 +264,7 @@ void UdpServer::sendSerialPortStatus(int serialPortStatus)
 
 void UdpServer::sendSbgSolutionModeState(int SolutionMode)
 {
-    std::cout<<"UdpServer::sendSbgSolutionModeState---------------------:"<< SolutionMode <<std::endl;
+//    std::cout<<"UdpServer::sendSbgSolutionModeState---------------------:"<< SolutionMode <<std::endl;
 
     QByteArray datagram2send;
 
@@ -277,13 +274,13 @@ void UdpServer::sendSbgSolutionModeState(int SolutionMode)
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
 }
 
-void UdpServer::sendSbgAccuracyState(int Accuracy)
+void UdpServer::sendSbgAccuracyState(int Accuracy,int SatelliteCounter)
 {
 //    std::cout<<"UdpServer::sendSbgAccuracyState---------------------:"<< Accuracy <<std::endl;
 
     QByteArray datagram2send;
 
-    QString status = "Accuracy," + QString::number(Accuracy);
+    QString status = "Accuracy," + QString::number(Accuracy) + "," + QString::number(SatelliteCounter);
 
     datagram2send.operator =(status.toStdString().c_str());
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
@@ -291,7 +288,7 @@ void UdpServer::sendSbgAccuracyState(int Accuracy)
 
 void UdpServer::sendXimeaImageStatus(int ximeaImageStatus)
 {
-    std::cout<<"UdpServer::sendXimeaImageStatus---------------------:"<< ximeaImageStatus <<std::endl;
+//    std::cout<<"UdpServer::sendXimeaImageStatus---------------------:"<< ximeaImageStatus <<std::endl;
 
     QByteArray datagram2send;
 
@@ -301,9 +298,45 @@ void UdpServer::sendXimeaImageStatus(int ximeaImageStatus)
     m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
 }
 
+void UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame(int autoExposeMaxValueOfOneFrame, double exposeTime)
+{
+//    std::cout<<"UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame---------------------:"<< ximeaImageStatus <<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);
+}
+
+void UdpServer::sendXimeaBinState(int spatialBin, int spectralBin)
+{
+//    std::cout<<"UdpServer::sendXimeaAutoExposeMaxValueOfOneFrame---------------------:"<< ximeaImageStatus <<std::endl;
+
+    QByteArray datagram2send;
+
+    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);
+}
+
+void UdpServer::sendXimeaImageFrameRate(double frameRate)
+{
+//    std::cout<<"UdpServer::sendXimeaImageFrameRate---------------------:"<< ximeaImageStatus <<std::endl;
+
+    QByteArray datagram2send;
+
+    QString status = "XimeaFrameRate," + QString::number(frameRate, 'f', 2);
+
+    datagram2send.operator =(status.toStdString().c_str());
+    m_udpSocket->writeDatagram(datagram2send.data(),datagram2send.size(),m_clientIpAddress, 45455);
+}
+
 void UdpServer::sendCopyFileStatus(int fileStatus)
 {
-    std::cout<<"UdpServer::sendCopyFileStatus---------------------:"<< fileStatus <<std::endl;
+//    std::cout<<"UdpServer::sendCopyFileStatus---------------------:"<< fileStatus <<std::endl;
 
     QByteArray datagram2send;
 

Source_Files/utility_tc.cpp

@@ -1,6 +1,25 @@
 #include "Header_Files/utility_tc.h"
 #include <QDir>
 
+QString formatTimeStr(char * format)
+{
+    //获取系统时间
+    time_t timer;//time_t就是long int 类型
+    struct tm *tblock;
+    timer = time(NULL);//返回秒数(精度为秒)，从1970-1-1,00:00:00 可以当成整型输出或用于其它函数
+    tblock = localtime(&timer);
+    //printf("Local time is: %s\n", asctime(tblock));
+
+    //格式化时间为需要的格式
+    char timeStr_tmp[256] = { 0 };
+    strftime(timeStr_tmp, sizeof(timeStr_tmp), format, tblock);//
+
+    QString timeStr2(timeStr_tmp);
+//    qDebug() << "time is:" << timeStr2;
+
+    return timeStr2;
+}
+
 QString getFileNameBaseOnTime()
 {
     using namespace std;
@@ -69,3 +88,36 @@ void swap(unsigned short * a, unsigned short * b)
     *a=*b;
     *b=tmp;
 }
+
+
+bool createDir(QString fullPath)
+{
+    QDir dir(fullPath);
+    if (dir.exists()) {
+        return true;
+    } else {
+        bool ok = dir.mkpath(fullPath);//创建多级目录
+        return ok;
+    }
+}
+
+QList<QString> getFileInfo(QString file)
+{
+    QFileInfo fileInfo = QFileInfo(file);
+
+    QString fileName, fileSuffix, filePath;
+    filePath = fileInfo.absolutePath();//绝对路径
+    fileName = fileInfo.fileName();//文件名
+    fileSuffix = fileInfo.suffix();//文件后缀
+
+//    qDebug() << fileName <<endl
+//             << fileSuffix<< endl
+//             << filePath<< endl;
+
+    QList<QString> result;
+    result.append(filePath);
+    result.append(fileName);
+    result.append(fileSuffix);
+
+    return result;
+}

Source_Files/ximeaimager.cpp

@@ -7,19 +7,56 @@ XimeaImager::XimeaImager()
     m_iFrameCounter=0;
     m_iImagerState=100;
 
-    //connect(this, SIGNAL(recordFinished()),this, SLOT());
-
-    m_configfile.setConfigfilePath("ximea.cfg");
+    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();
 
     connect(this, SIGNAL(recordXimeaTemperatureSignal(QString)),m_ximeaTemperature, SLOT(recordTemperature(QString)));
+
+    writeData2DiskThread = new QThread();
+    writeData2Disk = new WriteData2Disk();
+    writeData2Disk->moveToThread(writeData2DiskThread);
+    writeData2DiskThread->start(QThread::HighestPriority);
+    connect(this, SIGNAL(startWriteDiskSignal()), writeData2Disk, SLOT(write2Disk()));
+
+    m_pool = new MemoryPool<DataBuffer>;
+    q = new queue<DataBuffer *>;
+    m_qFrameCounter = new queue<int>;
+
+    m_rgbImage = new rgbImage();
+}
+
+XimeaImager::~XimeaImager()
+{
+
 }
 
 void XimeaImager::openImger()
@@ -36,18 +73,24 @@ void XimeaImager::openImger()
         //std::cout<<"XimeaImager::openImger111111111111111111111:正在打开相机!"<<std::endl;
         m_imager.connect();
 
-        bool ret;
+        bool ret, ret1, ret2;
 
-        int bin=0;
-        ret = m_configfile.getBin(bin);
-        if (ret)
+        int spatialBin;
+        int spectralBin;
+        ret1 = m_configfile.getspatialBin(spatialBin);
+        ret2 = m_configfile.getSpectralBin(spectralBin);
+        if (ret1 & ret2)
         {
-            bool haha = m_imager.setSpectralBin(bin);
-            bool haha2 = m_imager.setSpatialBin(bin);
+            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);
@@ -58,29 +101,62 @@ void XimeaImager::openImger()
         if (ret)
         {
             m_imager.setEffectiveWindow(offsetx, width, offsety, height);
+            m_rgbImage->SetRgbImageWidthAndHeight(height, width, 20);
+            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;
-        ret = m_configfile.getEffectiveWindowRoi(width_roi, offsetx_roi);
-        if (ret)
+//        int width_roi = 0, offsetx_roi = 0;
+//        ret = m_configfile.getEffectiveWindowRoi(width_roi, offsetx_roi);
+//        if (ret)
+//        {
+//            m_imager.setEffectiveWindowRoi(offsetx_roi, width_roi);
+//        }
+
+        int bufferPolicy, acqBufferSize;
+        ret1 = m_configfile.getBufferPolicy(bufferPolicy);
+        if (ret1)
         {
-            m_imager.setEffectiveWindowRoi(offsetx_roi, width_roi);
+            m_imager.setBufferPolicy(bufferPolicy);
+        }
+        ret1 = m_configfile.getAcqBufferSize(acqBufferSize);
+        if (ret1)
+        {
+            m_imager.setAcqBufferSize(acqBufferSize);
         }
 
-        setFramerate(100);
+        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;
         int frameSizeAuto = m_imager.getBufferSizeOfOneFrame();
 
         m_iFrameSizeInByte = frameSizeAuto;
+        std::cout<<"每一帧的字节数：-------------------------------"<< m_iFrameSizeInByte <<std::endl;
 
         m_buffer = new unsigned short[m_iFrameSizeInByte];
 
         m_iImagerState = 101;
         emit ximeaImageStatus(m_iImagerState);
 
-        m_ximeaTemperatureCSVPath = "/home/rock/programRunLog/ximeaTemperature.csv";
+        QDateTime curDateTime = QDateTime::currentDateTime();
+        QString currentTime = curDateTime.toString("yyyy_MM_dd_hh_mm_ss");
+        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);
     }
     catch(int xiApiErrorCodes)
@@ -128,12 +204,21 @@ void XimeaImager::setFramerate(double framerate)
     {
         m_imager.set_framerate(framerate);
 
-        int maxExposureTimeInUs=1/framerate*1000000*0.8;
-        setExposureTime(maxExposureTimeInUs);
-//        setExposureTime(1000);
+        int exposureTimeInUs = getExposureTime();
+
+        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)
     {
@@ -169,9 +254,7 @@ double XimeaImager::setExposureTime(float exposureTime_in_us)
         //确保设置的积分时间比最大积分时间小
         if(exposureTime_in_us<maxExposureTime_in_us)
         {
-
             m_imager.set_integration_time(exposureTime_in_us);
-
         }
         else
         {
@@ -180,6 +263,7 @@ double XimeaImager::setExposureTime(float exposureTime_in_us)
 
         //返回设置的积分时间
         integrationTime2Return=m_imager.get_integration_time();
+        m_parameterConfigfile.setExposeTime(integrationTime2Return);
 
         return integrationTime2Return;
     }
@@ -190,6 +274,24 @@ double XimeaImager::setExposureTime(float exposureTime_in_us)
     }
 }
 
+int XimeaImager::wrapSetExposureTime(float exposureTime_in_us)
+{
+    double exposureTime = setExposureTime(exposureTime_in_us);
+
+    m_imager.start();
+    m_imager.get_frame(m_buffer);
+    m_imager.stop();
+
+    int maxValueOfOneFrame = getMaxValueOfOneFrame((short unsigned int*)m_imager.m_image.bp,m_imager.get_band_count()*m_imager.get_sample_count());
+
+    m_iImagerState=103;
+    emit ximeaImageStatus(m_iImagerState);
+
+    emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime);
+
+    return maxValueOfOneFrame;
+}
+
 double XimeaImager::autoExposure()
 {
     double exposureTime;
@@ -200,17 +302,20 @@ double XimeaImager::autoExposure()
         float suitableMaxValue=4095 * 0.8;
 
         double framerate = m_imager.get_framerate();
-        double maxExposureTime = 1/framerate*1000000;
+        double maxExposureTime = 1/framerate*1000000*0.95;//0.95目的：避免曝光时间超过最大，而造成帧率降低
         exposureTime=setExposureTime(maxExposureTime);
 
         bool bIsAutoExposureOk=false;
         while(!bIsAutoExposureOk)
         {
+            std::cout<<"自动曝光本次时间为："<< exposureTime <<std::endl;
+
             m_imager.start();
             m_imager.get_frame(m_buffer);
             m_imager.stop();
 
-            maxValueOfOneFrame=getMaxValueOfOneFrame(m_buffer,m_imager.get_band_count()*m_imager.get_sample_count());
+            maxValueOfOneFrame=getMaxValueOfOneFrame((short unsigned int*)m_imager.m_image.bp,m_imager.get_band_count()*m_imager.get_sample_count());
+            printf("本帧最大值为: %d.\n",maxValueOfOneFrame);
 
             if(maxValueOfOneFrame <= suitableMaxValue)
             {
@@ -245,6 +350,7 @@ double XimeaImager::autoExposure()
 
         m_iImagerState=103;
         emit ximeaImageStatus(m_iImagerState);
+        emit autoExposeMaxValueOfOneFrame(maxValueOfOneFrame, exposureTime);
 
         std::cout<<"自动曝光完成!"<<std::endl;
         return exposureTime;
@@ -402,7 +508,6 @@ int XimeaImager::getMaxValueOfOneFrame(unsigned short * data, int numberOfPixel)
             int a=0;
         }
     }
-    printf("本帧最大值为: %d.\n",maxValue);
 
     return maxValue;
 }
@@ -412,15 +517,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;
         }
 
@@ -429,94 +560,128 @@ void XimeaImager::startRecord(double TimeDifferenceBetweensOSAndSbg,QString base
         m_iImagerState=104;
         emit ximeaImageStatus(m_iImagerState);
 
-        printf("开始采集!\n");
+        char * timeFormat="%Y%m%d_%H%M%S";
+        QString timeStr = formatTimeStr(timeFormat);
+        printf("开始采集：%s!\n", timeStr.toStdString().c_str());
+
         m_iFrameCounter=0;
         m_bRecordControl=true;
 
-        m_imager.start();
-
         m_baseFileName=baseFileName;
 
-        QString imageFileName=m_baseFileName+".bil";
-        QString timesFileName=m_baseFileName+".times";
-
-        //
-        FILE *hFile=fopen(imageFileName.toStdString().c_str(),"w+b");
-        FILE *hHimesFile=fopen(timesFileName.toStdString().c_str(),"w+");
+        std::cout << "帧率为：" << getFramerate() << "hz" <<std::endl;
+        std::cout << "曝光时间为：" << getExposureTime() << "μs" <<std::endl;
 
         using namespace std;
-        ofstream timesFileHandle(timesFileName.toStdString()+"_ofstream");
+//        ofstream timesFileHandle(timesFileName.toStdString()+"_ofstream");
 
+        int number_WriteDisk = 100;
+        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];
+
+        m_imager.start();
         struct timeval timeStart, timeEnd;
         double runTime=0;
         gettimeofday(&timeStart, NULL);
-
         while (m_bRecordControl)
         {
             unsigned short *x=m_imager.get_frame(m_buffer);
-
-            //fwrite(m_buffer,2,getBandCount()*getSampleCount(),hFile);
-            fwrite(m_buffer,1,m_iFrameSizeInByte,hFile);//*********************************
-            //fflush(hFile);//只保证了将IO缓冲写入系统缓冲中，使IO读操作能成功，但系统什么时候写入磁盘，由系统决定，一般是达到一定量时系统他就写入磁盘。
-            //sync();//强制系统将系统文件缓冲的内容写入磁盘
-
             m_iFrameCounter+=1;
 
-//            if(m_iFrameCounter==100)
-//                break;
+            if (m_iFrameCounter == 1)
+            {
+                timeDifferenceBetweenSbgAndXimea = calculateTimeDifferenceBetweenSbgAndximea(&m_imager.m_image, TimeDifferenceBetweensOSAndSbg);
+            }
 
-            double sbgTime=getSbgTime(TimeDifferenceBetweensOSAndSbg);
+            indexofbuff = m_iFrameCounter % number_WriteDisk;
 
-            fprintf(hHimesFile,"%f\n",sbgTime);
-            //fwrite(&sbgTime,sizeof(double),1,hHimesFile);
+            if (indexofbuff == 1)
+            {
+                r_qtx.lock();
+                buffer = m_pool->newElement();
+                r_qtx.unlock();
+            }
 
-            timesFileHandle << sbgTime << "\n";
+            if (indexofbuff == 0)
+            {
+                memcpy((void *)buffer->data + (number_WriteDisk - 1) * m_iFrameSizeInByte,m_imager.m_image.bp,m_iFrameSizeInByte);
+                sbgTimeBuffer[number_WriteDisk - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
+            }
+            else
+            {
+                memcpy((void *)buffer->data + (indexofbuff - 1) * m_iFrameSizeInByte,m_imager.m_image.bp,m_iFrameSizeInByte);
+                sbgTimeBuffer[indexofbuff - 1] = getSbgTime(&m_imager.m_image, timeDifferenceBetweenSbgAndXimea);
+            }
 
-//            std::cout<<"XimeaImager::startRecord---std::cout: "<<sbgTime<<std::endl;
+            if (indexofbuff == 0)
+            {
+                r_qtx.lock();
+                q->push(buffer);
+                m_qFrameCounter->push(number_WriteDisk);
+                r_qtx.unlock();
 
-//            //用于测试是否漏帧
-//            if(m_iFrameCounter==getFramerate()*20)
-//            {
-//                break;
-//            }
-
-//            unsigned char pixel = *(unsigned char*)image.bp;//Default value: XI_MONO8
-//            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)
+        {
+            r_qtx.lock();
+            q->push(buffer);
+            m_qFrameCounter->push(indexofbuff);
+            r_qtx.unlock();
 
+            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();
+
+        delete[] sbgTimeBuffer;
 
         double frameInTheory=runTime * getFramerate();
-        double frameLossed=frameInTheory - m_iFrameCounter;
-        double frameLossRate=frameLossed / frameInTheory;
 
-        std::cout<<"当前采集文件为: "<<baseFileName.toStdString()<<std::endl;
-        std::cout<<"采集时间为: "<<runTime<< "s" <<std::endl;
+        double frameLossed = m_imager.m_image.acq_nframe - m_iFrameCounter;
+        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(hFile);
         fclose(hHimesFile);
-        timesFileHandle.close();
+//        timesFileHandle.close();
+//        timesFile.close();
 
-        printf("Stopping acquisition...\n");
-        m_imager.stop();
-
-        writeHdr();
+        timeStr = formatTimeStr(timeFormat);
+        printf("停止采集：%s!\n", timeStr.toStdString().c_str());
 
         m_iImagerState=m_iImagerStateTemp;
         emit ximeaImageStatus(m_iImagerState);
 
         emit recordFinished();
-
-        emit recordXimeaTemperatureSignal(m_ximeaTemperatureCSVPath);//停止采集影像后，继续获取传感器温度；
     }
     catch(int xiApiErrorCodes)
     {
@@ -532,6 +697,11 @@ void XimeaImager::writeHdr()
 
     ofstream hdrFileHandle(hdrPath.toStdString());
     hdrFileHandle << "ENVI\n";
+
+    QString SN;
+    m_configfile.getSN(SN);
+    hdrFileHandle << "SN = " << SN.toStdString() << "\n";
+
     hdrFileHandle << "interleave = bil\n";
     hdrFileHandle << "byte order = 0\n";
     hdrFileHandle << "data type = 2\n";
@@ -551,16 +721,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);
-        if (i < getWindowEndBand() - 1)
-            hdrFileHandle << ", ";
-        else
+        for (int i = getWindowStartBand(); i < getWindowEndBand(); i++)
         {
-            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();
 }
@@ -639,6 +836,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;
@@ -665,19 +874,26 @@ void XimeaImager::processXiApiErrorCodes(int xiApiErrorCodes)
 
         break;
     default:
-        QString ximeaError="ximeaError.txt";
-        ofstream ximeaErrorFile(ximeaError.toStdString().c_str(),ios::app);
-
-        ximeaErrorFile<< xiApiErrorCodes << "\n";
-
-        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()
@@ -691,10 +907,20 @@ int XimeaImager::getFrameCounter()
     return m_iFrameCounter;
 }
 
-RecordXimeaTemperature::RecordXimeaTemperature(Iris::IrisXimeaImager * imager)
+DataBuffer::DataBuffer()
+{
+}
+
+DataBuffer::~DataBuffer()
+{
+}
+
+RecordXimeaTemperature::RecordXimeaTemperature(Iris::IrisXimeaImager * imager, XimeaImager * ximeaImager)
 {
     m_imager = imager;
     m_bIsRecord = true;
+
+    m_ximeaImager = ximeaImager;
 }
 
 void RecordXimeaTemperature::stopRecordTemperature()
@@ -706,11 +932,24 @@ 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)
+        {
+            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");
+        }
 
         QDateTime curDateTime = QDateTime::currentDateTime();
         QString currentTime = curDateTime.toString("yyyy/MM/dd hh:mm:ss");
@@ -718,7 +957,12 @@ void RecordXimeaTemperature::recordTemperature(QString filePath= nullptr)
         ximeaTemperatureFile << currentTime.toStdString() << "," << temp << "\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);
     }
 
@@ -726,3 +970,88 @@ void RecordXimeaTemperature::recordTemperature(QString filePath= nullptr)
 
     ximeaTemperatureFile.close();
 }
+
+WriteData2Disk::WriteData2Disk()
+{
+    isExitWriteData2Disk = false;
+}
+
+void WriteData2Disk::write2Disk()
+{
+    QString imageFileName=m_QbaseFileName+".bil";
+    FILE *hFile=fopen(imageFileName.toStdString().c_str(),"w+b");
+
+
+    int frameCounter = 0;
+    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 && 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)
+        {
+            continue;
+        }
+
+
+
+        r_qtx.lock();
+        DataBuffer * buffer = m_q->front();
+        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);
+
+
+//        std::cout<<"WriteData2Disk::write2Disk-----------------------正在写磁盘!" << m_pool->max_size() <<std::endl;//
+        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-----------------------写磁盘线程将退出，fwrite 调用次数：" << frameCounter <<std::endl;
+}
+
+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;
+}