Spi flash added.

Dual path added.

developHw.pro

@@ -22,7 +22,7 @@ SOURCES += \
     qcustomplot.cpp \
     api.cpp         \
     $$files(src/*.cpp, true) \
-    $$files(hdf5Scenario/*.cpp, true)
+    $$files(hdf5Scenario/*.cpp, true) \
 
 HEADERS += \
     mainwindow.h    \

developHw.pro.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 4.10.0, 2023-06-06T13:39:59. -->
+<!-- Written by QtCreator 4.10.0, 2023-08-02T02:43:42. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>

hdf5Scenario/hdf5Scenario.cpp

@@ -35,259 +35,331 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
     datasetBranch<float_t>("/sramParameters/rxBeamformerNo", floatArray);
     scenParams.rxBeamFormerNumber.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.rxBeamFormerNumber.push_back(static_cast<quint8>(floatArray[var]));
+    }
 
     /**************** /sramParameters/pulseInterval ********************/
     datasetBranch<float_t>("/sramParameters/pulseInterval", floatArray);
     scenParams.pulseInterval.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.pulseInterval.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/indexParameters/shotPropertiesIndex ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/shotPropertiesIndex", floatArray);
     scenParams.indexParams.shotPropertiesIndex.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.shotPropertiesIndex.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/pulsePropertiesIndex ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/pulsePropertiesIndex", floatArray);
     scenParams.indexParams.pulsePropertiesIndex.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.pulsePropertiesIndex.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
-    /**************** /sramParameters/indexParameters/receiverConfigurationIndex ********************/
+    /**************** /sramParameters/indexParameters/receiverConfigurationIndex
-    datasetBranch <float_t>("/sramParameters/indexParameters/receiverConfigurationIndex", floatArray);
+     ********************/
+    datasetBranch<float_t>("/sramParameters/indexParameters/receiverConfigurationIndex",
+                           floatArray);
     scenParams.indexParams.receiverConfigurationIndex.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
-        scenParams.indexParams.receiverConfigurationIndex.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.indexParams.receiverConfigurationIndex.push_back(static_cast<quint32>(floatArray[
+                                                                                             var]));
+    }
 
     /**************** /sramParameters/indexParameters/firstLineInFrame ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/firstLineInFrame", floatArray);
     scenParams.indexParams.firstLineInFrame.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.firstLineInFrame.push_back(static_cast<bool>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/startOfSubBatch ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/startOfSubBatch", floatArray);
     scenParams.indexParams.startOfSubBatch.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.startOfSubBatch.push_back(static_cast<bool>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/endOfSubBatch ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/endOfSubBatch", floatArray);
     scenParams.indexParams.endOfSubBatch.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.endOfSubBatch.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/endOfSubFrame ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/endOfSubFrame", floatArray);
     scenParams.indexParams.endOfSubFrame.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.endOfSubFrame.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/endOfEnsemble ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/endOfEnsemble", floatArray);
     scenParams.indexParams.endOfEnsemble.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.endOfEnsemble.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/indexParameters/isLastSubBatch ********************/
     datasetBranch<float_t>("/sramParameters/indexParameters/isLastSubBatch", floatArray);
     scenParams.indexParams.isLastSubBatch.clear();
     for(quint32 var = 0; var < scenParams.totalTxShotNumber; var++)
+    {
         scenParams.indexParams.isLastSubBatch.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/txParameters/txFocusXPos ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/txFocusXPos", floatArray);
     scenParams.txParams.txFocusXPos.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.txParams.txFocusXPos.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/txParameters/txFocusYPos ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/txFocusYPos", floatArray);
     scenParams.txParams.txFocusYPos.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.txParams.txFocusYPos.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/txParameters/txFocusZPos ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/txFocusZPos", floatArray);
     scenParams.txParams.txFocusZPos.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.txParams.txFocusZPos.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/txParameters/txStartActiveElementNo ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/txStartActiveElementNo", floatArray);
     scenParams.txParams.txStartActiveElementNumber.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
-        scenParams.txParams.txStartActiveElementNumber.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.txParams.txStartActiveElementNumber.push_back(static_cast<quint32>(floatArray[var
+                                                                                      ]));
+    }
 
     /**************** /sramParameters/txParameters/txActiveElementNo ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/txActiveElementNo", floatArray);
     scenParams.txParams.txActiveElementNumber.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.txParams.txActiveElementNumber.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/txParameters/maxDelayQ ********************/
     datasetBranch<float_t>("/sramParameters/txParameters/maxDelayQ", floatArray);
     scenParams.txParams.maxDelayQ.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.txParams.maxDelayQ.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/rxParameters/rxR0CenterActiveElementNo ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxR0CenterActiveElementNo", floatArray);
     scenParams.rxParams.rxR0CenterActiveElementNumber.clear();
     quint32 accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
-            scenParams.rxParams.rxR0CenterActiveElementNumber.push_back(static_cast<quint32>(floatArray[accum]));
+            scenParams.rxParams.rxR0CenterActiveElementNumber.push_back(static_cast<quint32>(
+                                                                            floatArray[accum]));
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/rxR0ActiveElementNo ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxR0ActiveElementNo", floatArray);
     scenParams.rxParams.rxR0ActiveElementNumber.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
-            scenParams.rxParams.rxR0ActiveElementNumber.push_back(static_cast<quint32>(floatArray[accum]));
+            scenParams.rxParams.rxR0ActiveElementNumber.push_back(static_cast<quint32>(floatArray[
+                                                                                           accum]));
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/rxActiveElementStep ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxActiveElementStep", floatArray);
     scenParams.rxParams.rxActiveElementStep.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.rxParams.rxActiveElementStep.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/rxParameters/interceptPointFiringTime ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/interceptPointFiringTime", floatArray);
     scenParams.rxParams.interceptPointFiringTime.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.rxParams.interceptPointFiringTime.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/rxParameters/rxFocusPointNo ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxFocusPointNo", floatArray);
     scenParams.rxParams.rxFocusPointNumber.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.rxParams.rxFocusPointNumber.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /sramParameters/rxParameters/r0Position ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/r0Position", floatArray);
     scenParams.rxParams.r0Position.clear();
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         scenParams.rxParams.r0Position.push_back(floatArray[var]);
+    }
 
     /**************** /sramParameters/rxParameters/thetaCos ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/thetaCos", floatArray);
     scenParams.rxParams.thetaCos.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.thetaCos.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/thetaSin ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/thetaSin", floatArray);
     scenParams.rxParams.thetaSin.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.thetaSin.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/phiCos ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/phiCos", floatArray);
     scenParams.rxParams.phiCos.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.phiCos.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/phiSin ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/phiSin", floatArray);
     scenParams.rxParams.phiSin.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.phiSin.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/interceptXPos ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/interceptXPos", floatArray);
     scenParams.rxParams.interceptXPos.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.interceptXPos.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/interceptYPos ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/interceptYPos", floatArray);
     scenParams.rxParams.interceptYPos.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.interceptYPos.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/interceptZPos ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/interceptZPos", floatArray);
     scenParams.rxParams.interceptZPos.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.interceptZPos.push_back(floatArray[accum]);
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/txR0MinDelayQ ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/txR0MinDelayQ", floatArray);
     scenParams.rxParams.txR0MinDelayQ.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.txR0MinDelayQ.push_back(static_cast<quint32>(floatArray[accum]));
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/rxR0MinDelayQ ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxR0MinDelayQ", floatArray);
     scenParams.rxParams.rxR0MinDelayQ.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.rxR0MinDelayQ.push_back(static_cast<quint32>(floatArray[accum]));
             accum++;
         }
+    }
 
     /**************** /sramParameters/rxParameters/rxR0MaxDelayQ ********************/
     datasetBranch<float_t>("/sramParameters/rxParameters/rxR0MaxDelayQ", floatArray);
     scenParams.rxParams.rxR0MaxDelayQ.clear();
     accum = 0;
     for(quint32 var = 0; var < scenParams.focusTypeNumber; var++)
+    {
         for(quint8 var1 = 0; var1 < scenParams.rxBeamFormerNumber[static_cast<qint32>(var)]; var1++)
         {
             scenParams.rxParams.rxR0MaxDelayQ.push_back(static_cast<quint32>(floatArray[accum]));
             accum++;
         }
+    }
 
     /**************** /registerParameters/pulseTypeNo ********************/
     datasetBranch<float_t>("/registerParameters/pulseTypeNo", floatArray);
@@ -326,43 +398,58 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
     datasetBranch<float_t>("/registerParameters/ddcParameters/startFreqLut", floatArray);
     scenParams.hwRegister.ddcParams.startFreqLut.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.startFreqLut.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /*********** /registerParameters/ddcParameters/endFreqLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/endFreqLut", floatArray);
     scenParams.hwRegister.ddcParams.endFreqLut.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.endFreqLut.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /*********** /registerParameters/ddcParameters/startFreqPointLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/startFreqPointLut", floatArray);
     scenParams.hwRegister.ddcParams.startFreqPoint.clear();
     for(quint32 var = 0; var < 4; var++)
-        scenParams.hwRegister.ddcParams.startFreqPoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.ddcParams.startFreqPoint.push_back(static_cast<quint32>(floatArray[var
+                                                                                      ]));
+    }
 
     /*********** /registerParameters/ddcParameters/endFreqPointLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/endFreqPointLut", floatArray);
     scenParams.hwRegister.ddcParams.endFreqPoint.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.endFreqPoint.push_back(static_cast<quint32>(floatArray[var]));
+    }
 
     /*********** /registerParameters/ddcParameters/freqStepLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/freqStepLut", floatArray);
     scenParams.hwRegister.ddcParams.freqStepLut.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.freqStepLut.push_back(floatArray[var]);
+    }
 
     /*********** /registerParameters/ddcParameters/lpfWeightStepLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/lpfWeightStepLut", floatArray);
     scenParams.hwRegister.ddcParams.lpfWeightStepLut.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.lpfWeightStepLut.push_back(floatArray[var]);
+    }
 
     /*********** /registerParameters/ddcParameters/startLpfWeightLut ***************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/startLpfWeightLut", floatArray);
     scenParams.hwRegister.ddcParams.startLpfWeightLut.clear();
     for(quint32 var = 0; var < 4; var++)
+    {
         scenParams.hwRegister.ddcParams.startLpfWeightLut.push_back(floatArray[var]);
+    }
 
     /*********** /registerParameters/ddcParameters/startLpfLut ****************/
     datasetBranch<float_t>("/registerParameters/ddcParameters/startLpfLut", floatArray);
@@ -395,31 +482,50 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
     datasetBranch<float_t>("/registerParameters/ddcParameters/lpfScale", floatArray);
     scenParams.hwRegister.ddcParams.lpfScale.clear();
     for(quint8 i = 0; i < 4; i++)
+    {
         scenParams.hwRegister.ddcParams.lpfScale.push_back(static_cast<quint8>(floatArray[i]));
+    }
 
     /**************** /registerParameters/dTgcLut ********************/
     datasetBranch<float_t>("/registerParameters/dTgcLut", floatArray);
     scenParams.hwRegister.dtgcLut.clear();
     for(quint32 var = 0; var < 1024; var++)
+    {
         scenParams.hwRegister.dtgcLut.push_back(floatArray[var]);
+    }
+
+    /**************** /registerParameters/dualPathWeight ********************/
+//datasetBranch<float_t>("/registerParameters/dualPathWeightQ", floatArray);
+    scenParams.hwRegister.dualPathWeight.clear();
+    for(quint32 var = 0; var < 1024; var++)
+    {
+//scenParams.hwRegister.dualPathWeight.push_back(static_cast<quint32>(floatArray[var]));
+        scenParams.hwRegister.dualPathWeight.push_back(0);
+    }
 
     /**************** /registerParameters/elementXPositions ********************/
     datasetBranch<float_t>("/registerParameters/elementXPositions", floatArray);
     scenParams.hwRegister.elementXPosition.clear();
     for(quint32 var = 0; var < 192; var++)
+    {
         scenParams.hwRegister.elementXPosition.push_back(floatArray[var]);
+    }
 
     /**************** /registerParameters/elementYPositions ********************/
     datasetBranch<float_t>("/registerParameters/elementYPositions", floatArray);
     scenParams.hwRegister.elementYPosition.clear();
     for(quint32 var = 0; var < 192; var++)
+    {
         scenParams.hwRegister.elementYPosition.push_back(floatArray[var]);
+    }
 
     /**************** /registerParameters/elementZPositions ********************/
     datasetBranch<float_t>("/registerParameters/elementZPositions", floatArray);
     scenParams.hwRegister.elementZPosition.clear();
     for(quint32 var = 0; var < 192; var++)
+    {
         scenParams.hwRegister.elementZPosition.push_back(floatArray[var]);
+    }
 
     /**************** /registerParameters/scenarioStartIndex ********************/
     datasetBranch<float_t>("/registerParameters/scenarioStartIndex", floatArray);
@@ -438,7 +544,6 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         halfPeriod.push_back(static_cast<quint32>(floatArray[j]));
     }
 
-
     /**************** /registerParameters/pulseProperties/halfCycleNo ********************/
     datasetBranch<float_t>("/registerParameters/pulseProperties/halfCycleNo", floatArray);
     QList<quint32> halfCycleNo;
@@ -490,7 +595,6 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         scenParams.hwRegister.pulseProps.push_back(pulseObj);
     }
 
-
     /**************** /registerParameters/rxBeamformerProperties/mla ********************/
     datasetBranch<float_t>("/registerParameters/rxBeamformerProperties/mla", floatArray);
     QList<quint32> mla;
@@ -509,7 +613,8 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         lag.push_back(static_cast<quint32>(floatArray[j]));
     }
 
-    /**************** /registerParameters/rxBeamformerProperties/apodizationSel ********************/
+    /**************** /registerParameters/rxBeamformerProperties/apodizationSel
+     ********************/
     datasetBranch<float_t>("/registerParameters/rxBeamformerProperties/apodizationSel", floatArray);
     QList<quint32> apodizationSel;
 
@@ -535,73 +640,118 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
     datasetBranch<float_t>("/registerParameters/apodizationParameters/maxApertureSize", floatArray);
     scenParams.hwRegister.apodizationParams.maxApertureSize.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.maxApertureSize.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.maxApertureSize.push_back(static_cast<quint32>(
+                                                                              floatArray[var]));
+    }
 
     /********* /registerParameters/apodizationParameters/winOpenStartPoint ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/winOpenStartPoint", floatArray);
+    datasetBranch<float_t>("/registerParameters/apodizationParameters/winOpenStartPoint",
+                           floatArray);
     scenParams.hwRegister.apodizationParams.winOpenStartPoint.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.winOpenStartPoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.winOpenStartPoint.push_back(static_cast<quint32>(
+                                                                                floatArray[var]));
+    }
 
     /********* /registerParameters/apodizationParameters/winOpenStopPoint ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/winOpenStopPoint", floatArray);
+    datasetBranch<float_t>("/registerParameters/apodizationParameters/winOpenStopPoint",
+                           floatArray);
     scenParams.hwRegister.apodizationParams.winOpenStopPoint.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.winOpenStopPoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.winOpenStopPoint.push_back(static_cast<quint32>(
+                                                                               floatArray[var]));
+    }
 
     /********* /registerParameters/apodizationParameters/winOpenStartVal ************/
     datasetBranch<float_t>("/registerParameters/apodizationParameters/winOpenStartVal", floatArray);
     scenParams.hwRegister.apodizationParams.winOpenStartVal.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
+    {
         scenParams.hwRegister.apodizationParams.winOpenStartVal.push_back(floatArray[var]);
+    }
 
     /********* /registerParameters/apodizationParameters/winOpenStopVal ************/
     datasetBranch<float_t>("/registerParameters/apodizationParameters/winOpenStopVal", floatArray);
     scenParams.hwRegister.apodizationParams.winOpenStopVal.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
+    {
         scenParams.hwRegister.apodizationParams.winOpenStopVal.push_back(floatArray[var]);
+    }
 
     /********* /registerParameters/apodizationParameters/winOpenStepVal ************/
     datasetBranch<float_t>("/registerParameters/apodizationParameters/winOpenStepVal", floatArray);
     scenParams.hwRegister.apodizationParams.winOpenStepVal.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
+    {
         scenParams.hwRegister.apodizationParams.winOpenStepVal.push_back(floatArray[var]);
+    }
 
     /********* /registerParameters/apodizationParameters/minApertureSize ************/
     datasetBranch<float_t>("/registerParameters/apodizationParameters/minApertureSize", floatArray);
     scenParams.hwRegister.apodizationParams.minApertureSize.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.minApertureSize.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.minApertureSize.push_back(static_cast<quint32>(
+                                                                              floatArray[var]));
+    }
 
     /********* /registerParameters/apodizationParameters/rxActiveElementStep1 ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/rxActiveElementStep1", floatArray);
+    datasetBranch<float_t>("/registerParameters/apodizationParameters/rxActiveElementStep1",
+                           floatArray);
     scenParams.hwRegister.apodizationParams.rxActiveElementStep1.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
+    {
         scenParams.hwRegister.apodizationParams.rxActiveElementStep1.push_back(floatArray[var]);
+    }
 
     /********* /registerParameters/apodizationParameters/rxActiveElementStep2 ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/rxActiveElementStep2", floatArray);
+    datasetBranch<float_t>("/registerParameters/apodizationParameters/rxActiveElementStep2",
+                           floatArray);
     scenParams.hwRegister.apodizationParams.rxActiveElementStep2.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
+    {
         scenParams.hwRegister.apodizationParams.rxActiveElementStep2.push_back(floatArray[var]);
+    }
 
     /********* /registerParameters/apodizationParameters/rxActiveElementStepStartPoint ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/rxActiveElementStepStartPoint", floatArray);
+    datasetBranch<float_t>(
+        "/registerParameters/apodizationParameters/rxActiveElementStepStartPoint",
+        floatArray);
     scenParams.hwRegister.apodizationParams.rxActiveElementStepStartPoint.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.rxActiveElementStepStartPoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.rxActiveElementStepStartPoint.push_back(static_cast<
+                                                                                            quint32>(
+                                                                                            floatArray
+                                                                                            [var]));
+    }
 
     /********* /registerParameters/apodizationParameters/rxActiveElementStepStopPoint ************/
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/rxActiveElementStepStopPoint", floatArray);
+    datasetBranch<float_t>("/registerParameters/apodizationParameters/rxActiveElementStepStopPoint",
+                           floatArray);
     scenParams.hwRegister.apodizationParams.rxActiveElementStepStopPoint.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.rxActiveElementStepStopPoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.rxActiveElementStepStopPoint.push_back(static_cast<
+                                                                                           quint32>(
+                                                                                           floatArray
+                                                                                           [var]));
+    }
 
-    /********* /registerParameters/apodizationParameters/rxActiveElementStepChangePoint ************/
+    /********* /registerParameters/apodizationParameters/rxActiveElementStepChangePoint
-    datasetBranch <float_t>("/registerParameters/apodizationParameters/rxActiveElementStepChangePoint", floatArray);
+     ************/
+    datasetBranch<float_t>(
+        "/registerParameters/apodizationParameters/rxActiveElementStepChangePoint",
+        floatArray);
     scenParams.hwRegister.apodizationParams.rxActiveElementStepChangePoint.clear();
     for(quint32 var = 0; var < scenParams.hwRegister.rxBeamFormerTypeNumber; var++)
-        scenParams.hwRegister.apodizationParams.rxActiveElementStepChangePoint.push_back(static_cast<quint32>(floatArray[var]));
+    {
+        scenParams.hwRegister.apodizationParams.rxActiveElementStepChangePoint.push_back(
+            static_cast<quint32>(floatArray[var]));
+    }
 
     /**************** /registerParameters/receiverConfigProperties/mla ********************/
     datasetBranch<float_t>("/registerParameters/receiverConfigProperties/mla", floatArray);
@@ -648,8 +798,10 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         stb.push_back(static_cast<quint32>(floatArray[j]));
     }
 
-    /**************** /registerParameters/receiverConfigProperties/subtractFilterEn ********************/
+    /**************** /registerParameters/receiverConfigProperties/subtractFilterEn
-     datasetBranch <float_t>("/registerParameters/receiverConfigProperties/subtractFilterEn", floatArray);
+     ********************/
+    datasetBranch<float_t>("/registerParameters/receiverConfigProperties/subtractFilterEn",
+                           floatArray);
     QList<quint32> subtractFilterEn;
 
     for(quint32 j = 0; j < scenParams.hwRegister.receiverConfigTypeNumber; j++)
@@ -675,6 +827,16 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         ncoFreqSel.push_back(static_cast<quint32>(floatArray[j]));
     }
 
+    /**************** /registerParameters/receiverConfigProperties/dualPathEn ********************/
+//datasetBranch<float_t>("/registerParameters/receiverConfigProperties/dualPathEn", floatArray);
+    QList<quint32> dualPathEn;
+
+    for(quint32 j = 0; j < scenParams.hwRegister.receiverConfigTypeNumber; j++)
+    {
+//dualPathEn.push_back(static_cast<quint32>(floatArray[j]));
+        dualPathEn.push_back(static_cast<quint32>(0));
+    }
+
     /**************** /registerParameters/receiverConfigProperties/lpfSel ********************/
     datasetBranch<float_t>("/registerParameters/receiverConfigProperties/lpfSel", floatArray);
     QList<quint32> lpfSel;
@@ -702,8 +864,10 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         focusNo.push_back(static_cast<quint32>(floatArray[j]));
     }
 
-    /**************** /registerParameters/receiverConfigProperties/iqDataCrossEn ********************/
+    /**************** /registerParameters/receiverConfigProperties/iqDataCrossEn
-     datasetBranch <float_t>("/registerParameters/receiverConfigProperties/iqDataCrossEn", floatArray);
+     ********************/
+    datasetBranch<float_t>("/registerParameters/receiverConfigProperties/iqDataCrossEn",
+                           floatArray);
     QList<quint32> iqDataCrossEn;
 
     for(quint32 j = 0; j < scenParams.hwRegister.receiverConfigTypeNumber; j++)
@@ -747,8 +911,10 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         frameType.push_back(static_cast<quint32>(floatArray[j]));
     }
 
-    /**************** /registerParameters/receiverConfigProperties/noiseRejectEn ********************/
+    /**************** /registerParameters/receiverConfigProperties/noiseRejectEn
-    datasetBranch <float_t>("/registerParameters/receiverConfigProperties/noiseRejectEn", floatArray);
+     ********************/
+    datasetBranch<float_t>("/registerParameters/receiverConfigProperties/noiseRejectEn",
+                           floatArray);
     QList<quint32> noiseRejectEn;
 
     for(quint32 j = 0; j < scenParams.hwRegister.receiverConfigTypeNumber; j++)
@@ -786,6 +952,7 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
         receiverCfgObj.frameType = frameType.at(j);
         receiverCfgObj.dcCancelEn = dcCancelEn.at(j);
         receiverCfgObj.ncoFreqSel = ncoFreqSel.at(j);
+        receiverCfgObj.dualPathEn = dualPathEn.at(j);
         receiverCfgObj.iqDataCrossEn = iqDataCrossEn.at(j);
         receiverCfgObj.noiseRejectEn = noiseRejectEn.at(j);
         receiverCfgObj.subtractFilterEn = subtractFilterEn.at(j);
@@ -815,7 +982,6 @@ void Hdf5::scenarioRead(ScenHardware &scenParams)
     scenParams.hwRegister.noiseRejectValue = static_cast<quint32>(floatArray[0]);
 }
 
-
 void Hdf5::prbDependParamsRead(ScenPrbDepHardwareParam& prbDepParams)
 {
     /**************** /registerParameters/apodizationLut ********************/
@@ -833,7 +999,6 @@ void Hdf5::prbDependParamsRead(ScenPrbDepHardwareParam &prbDepParams)
         prbDepParams.prbDepParams.apodizationLut.push_back(tempApodization);
     }
 
-
     /************ /registerParameters/aTgcParameters/aTgcLut ****************/
     datasetBranch<float_t>("/registerParameters/aTgcParameters/aTgcLut", floatArray);
     QList<QList<quint32> > atgcLut;
@@ -874,14 +1039,16 @@ void Hdf5::prbDependParamsRead(ScenPrbDepHardwareParam &prbDepParams)
     }
 }
 
-
 QVector<quint32> Hdf5::stbRead()
 {
     /**************** /registerParameters/stbLutQ ********************/
     datasetBranch<float_t>("/registerParameters/stbLutQ", floatArray);
     QVector<quint32> stb;
     for(quint8 var = 0; var < 8; var++)
+    {
         stb.push_back(static_cast<quint32>(floatArray[var]));
+    }
+
     return stb;
 }
 
@@ -891,6 +1058,9 @@ QVector<float> Hdf5::lineFilterRead()
     datasetBranch<float_t>("/registerParameters/lineFilterLut", floatArray);
     QVector<float> lineFilter;
     for(quint8 var = 0; var < 3; var++)
+    {
         lineFilter.push_back(floatArray[var]);
+    }
+
     return lineFilter;
 }

include/model/hardware/core/lowLevelApi/TrxBoard.h

@@ -16,6 +16,7 @@
 #include "register/builtInTest/BuiltInTest.h"
 #include "register/beamFormer/BeamFormer.h"
 #include "register/scenPlayer/ScenPlayer.h"
+#include "register/spiFlash/SpiFlash.h"
 #include "register/bpiFlash/BpiFlash.h"
 #include "register/emulator/Emulator.h"
 #include "register/debug/Debug.h"
@@ -59,6 +60,7 @@ class TrxBoard : public QObject
 	Q_OBJECT
 
 private:
+    QByteArray bin;
     QVector<quint8> _swapVec;
     QVector<quint32> _unsignedQntzrVec;
     QList<quint32> _unsignedQntzrList;
@@ -93,6 +95,7 @@ private:
     Debug* _debugSlave1;
     Debug* _debugSlave2;
 	BpiFlash* _bpiFlash;
+    SpiFlash* _spiFlash;
 	Afe* _afeSlave0;
 	Afe* _afeSlave1;
 	Afe* _afeSlave2;
@@ -130,6 +133,7 @@ private:
         QVector<float> startLpfWeightLut;
         QVector<float> freqLut;
 		QVector<float> dtgcLut;
+        QList<quint32> dualPathWeight;
 		ReceiverConfiguration* configLut;
         FreqPoint* freqPoint;
         QVector<QVector<float> > blendWeight;
@@ -287,6 +291,11 @@ public:
 	void mcsProgram(QString path);
 	void mcsVerify(QString path) const;
 
+    //////////////////////////////// SPI Flash API ////////////////////////////////
+    void spiFlashProgram(QString path);
+    void spiFlashRead(QString path);
+    void spiFlashVerify();
+
     //////////////////////////////// Miscellaneous API ////////////////////////////
 	void getTrxStatus(StatusVec* status) const;
 	void getFpgasCodeVersion(FpgaCodeVersion* version) const;

include/model/hardware/core/lowLevelApi/TrxBoardUtils/ScenParamsRanges.h

@@ -14,6 +14,7 @@
 #define FREQUENCY_LUT_MAX 8
 #define END_FREQ_LUT_MAX 4U
 #define LPF_SCALE_MAX 4
+#define DUAL_PATH_MAX 1024
 #define DTGC_LUT_MAX 1024
 #define ATGC_LUT_MAX 4
 #define LPF_LUT_MAX 4

include/model/hardware/core/lowLevelApi/TrxBoardUtils/TrxBoardStructures.h

@@ -92,6 +92,7 @@ struct ReceiverConfig
     quint32 subtractFilterEn;
     quint32 dcCancelEn;
     quint32 ncoFreqSel;
+    quint32 dualPathEn;
     quint32 lpfSel;
     quint32 absEn;
     quint32 focusNo;
@@ -138,6 +139,7 @@ struct ApodizationParameters
 struct HwRegister
 {
     QVector<float> dtgcLut;
+    QList<quint32> dualPathWeight;
     QVector<QVector<float> > blendWeight;
     QVector<float> elementXPosition;
     QVector<float> elementYPosition;

include/model/hardware/core/lowLevelApi/register/boardsCtrlMngt/BoardsCtrlMngt.h

@@ -24,7 +24,7 @@
 #define HVB_GAIN 2.635f
 
 #define HVA_MAX_VALUE 66.0f
-#define HVB_MAX_VALUE 66.0f //must be check
+#define HVB_MAX_VALUE 64.0f
 
 #define FAN1_PRI    127U    //Equal to 10.4ms according to the pulse gen submodule in HDL code
 #define FAN2_PRI    127U    //Equal to 10.4ms according to the pulse gen submodule in HDL code