| 
						
						
							
								
							
						
						
					 | 
					@ -41,34 +41,34 @@ void TrxBoard::sonoHeartBeatsDisable(void) const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->afesHeartBeatDisable(true); | 
					 | 
					 | 
					    this->afesHeartBeatDisable(true); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					void TrxBoard::sendPacket() | 
					 | 
					 | 
					//void TrxBoard::sendPacket()
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					{ | 
					 | 
					 | 
					//{
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					    auto counter(0); | 
					 | 
					 | 
					//    auto counter(0);
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					    while(_run) | 
					 | 
					 | 
					//    while(_run)
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					    { | 
					 | 
					 | 
					//    {
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        if(_swCounter == 0) | 
					 | 
					 | 
					//        if(_swCounter == 0)
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        { | 
					 | 
					 | 
					//        {
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            std::this_thread::sleep_for(std::chrono::milliseconds(3)); | 
					 | 
					 | 
					//            std::this_thread::sleep_for(std::chrono::milliseconds(3));
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            continue; | 
					 | 
					 | 
					//            continue;
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        } | 
					 | 
					 | 
					//        }
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        else if(_swCounter != counter) | 
					 | 
					 | 
					//        else if(_swCounter != counter)
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        { | 
					 | 
					 | 
					//        {
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            auto framePacket = QByteArray::fromRawData(_device.getBufferPtr(counter), BUFFER_SIZE); | 
					 | 
					 | 
					//            auto framePacket = QByteArray::fromRawData(_device.getBufferPtr(counter), BUFFER_SIZE);
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					#ifdef DEVELOP_UI | 
					 | 
					 | 
					//#ifdef DEVELOP_UI
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            emit sendFramePacket(framePacket); | 
					 | 
					 | 
					//            emit sendFramePacket(framePacket);
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					#else | 
					 | 
					 | 
					//#else
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            packetEngine.newData(framePacket); | 
					 | 
					 | 
					//            packetEngine.newData(framePacket);
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					#endif | 
					 | 
					 | 
					//#endif
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            counter++; | 
					 | 
					 | 
					//            counter++;
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            if(counter >= SW_BUFFER_NUM) | 
					 | 
					 | 
					//            if(counter >= SW_BUFFER_NUM)
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            { | 
					 | 
					 | 
					//            {
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					                counter = 0; | 
					 | 
					 | 
					//                counter = 0;
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					            } | 
					 | 
					 | 
					//            }
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					        } | 
					 | 
					 | 
					//        }
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					    } | 
					 | 
					 | 
					//    }
 | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					} | 
					 | 
					 | 
					//}
 | 
				
			
			
				
				
			
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					void TrxBoard::readData() | 
					 | 
					 | 
					void TrxBoard::readData() | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -106,7 +106,7 @@ void TrxBoard::readData() | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					               (batch - preBatch > 1) || | 
					 | 
					 | 
					               (batch - preBatch > 1) || | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					               (batch - preBatch == 1 && subBbatch != 0)) | 
					 | 
					 | 
					               (batch - preBatch == 1 && subBbatch != 0)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					            { | 
					 | 
					 | 
					            { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					                //throw SonoException("Batch/subBatch id error is occured.");
 | 
					 | 
					 | 
					                //throw HardwareException(DMA_XFER_ERROR, "Batch/subBatch id error occured.");
 | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					            } | 
					 | 
					 | 
					            } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					            preBatch = batch; | 
					 | 
					 | 
					            preBatch = batch; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					            preSubBatch = subBbatch; | 
					 | 
					 | 
					            preSubBatch = subBbatch; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -170,8 +170,8 @@ void TrxBoard::afeAdcsSync(const quint8& slaveMounted) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                             { | 
					 | 
					 | 
					                             { | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                                 if(this->_bCtrlMngt->checkTimeout()) | 
					 | 
					 | 
					                                 if(this->_bCtrlMngt->checkTimeout()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                                 { | 
					 | 
					 | 
					                                 { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					                                     throw SonoException( | 
					 | 
					 | 
					                                     throw HardwareException(AFE_ERROR, | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					                                               "The timeout of the afe adcs sync is happend without receiving of sync done."); | 
					 | 
					 | 
					                                               "The timeout of the afe adcs sync happend without receiving of sync done."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					                                 } | 
					 | 
					 | 
					                                 } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                             } | 
					 | 
					 | 
					                             } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                             this->_bCtrlMngt->timerStop(); | 
					 | 
					 | 
					                             this->_bCtrlMngt->timerStop(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -181,8 +181,8 @@ void TrxBoard::afeAdcsSync(const quint8& slaveMounted) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                                 quint32 syncErr = Slave->getAfeSyncError(); | 
					 | 
					 | 
					                                 quint32 syncErr = Slave->getAfeSyncError(); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                                 if(syncErr != 0) | 
					 | 
					 | 
					                                 if(syncErr != 0) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                                 { | 
					 | 
					 | 
					                                 { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					                                     throw SonoException( | 
					 | 
					 | 
					                                     throw HardwareException(AFE_ERROR, | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					                                               "The error of the afe adcs sync is happend."); | 
					 | 
					 | 
					                                               "The error of the afe adcs sync happend."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					                                 } | 
					 | 
					 | 
					                                 } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                             } | 
					 | 
					 | 
					                             } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					                         }; | 
					 | 
					 | 
					                         }; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -219,7 +219,7 @@ void TrxBoard::waitForCaptureDone(Debug* _dbg) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("Failure to receive adc capture done."); | 
					 | 
					 | 
					            throw HardwareException(AFE_ERROR, "Failure to receive adc capture done."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -253,7 +253,7 @@ void TrxBoard::adcLogTransferRoutine(Debug* _dbg, quint8 chNumPerFpga) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("Failure to receive adc log transfer done."); | 
					 | 
					 | 
					            throw HardwareException(AFE_ERROR, "Failure to receive adc log transfer done."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -269,7 +269,7 @@ void TrxBoard::adcLogTransferRoutine(Debug* _dbg, quint8 chNumPerFpga) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
					 | 
					 | 
					        if(this->_bCtrlMngt->checkTimeout()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("Failure to receive adc sampler done."); | 
					 | 
					 | 
					            throw HardwareException(AFE_ERROR, "Failure to receive adc sampler done."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -277,7 +277,7 @@ void TrxBoard::adcLogTransferRoutine(Debug* _dbg, quint8 chNumPerFpga) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(adcSamplerError) | 
					 | 
					 | 
					    if(adcSamplerError) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("The adc sampler error is occured."); | 
					 | 
					 | 
					        throw HardwareException(AFE_ERROR, "The adc sampler error occured."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    //Adc logger stop
 | 
					 | 
					 | 
					    //Adc logger stop
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -515,7 +515,7 @@ void TrxBoard::fpgaProgram(const QString path, const quint8& slaveMounted) const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(slaveMounted <= 0 || slaveMounted >= 8) | 
					 | 
					 | 
					    if(slaveMounted <= 0 || slaveMounted >= 8) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Wrong mounted slave fpga is selected"); | 
					 | 
					 | 
					        throw HardwareException(SLAVE_PROG_FAILED, "Wrong mounted slave fpga has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QByteArray bitFileData; | 
					 | 
					 | 
					    QByteArray bitFileData; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -524,12 +524,12 @@ void TrxBoard::fpgaProgram(const QString path, const quint8& slaveMounted) const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(bitFile.fileName().isEmpty()) | 
					 | 
					 | 
					    if(bitFile.fileName().isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(SLAVE_PROG_FAILED, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!bitFile.open(QIODevice::ReadOnly)) | 
					 | 
					 | 
					    if(!bitFile.open(QIODevice::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open bit file programming"); | 
					 | 
					 | 
					        throw HardwareException(SLAVE_PROG_FAILED, "Couldn't open bit file programming."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    bitFileData = bitFile.readAll(); | 
					 | 
					 | 
					    bitFileData = bitFile.readAll(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -612,7 +612,7 @@ void TrxBoard::gtReadReset() | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(error) | 
					 | 
					 | 
					        if(error) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("The GT error is happened and it's didn't solve by gt reset."); | 
					 | 
					 | 
					            throw HardwareException(SCEN_GT_ERROR, "The GT error happened and it didn't solve by gt reset."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -628,12 +628,12 @@ void TrxBoard::mcsRead(const QString path) const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(path.isEmpty()) | 
					 | 
					 | 
					    if(path.isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!mcsFile.open(QIODevice::WriteOnly)) | 
					 | 
					 | 
					    if(!mcsFile.open(QIODevice::WriteOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open BPI bin file programming"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "Couldn't open BPI bin file programming."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    mcsList = this->_bpiFlash->readMcs(); | 
					 | 
					 | 
					    mcsList = this->_bpiFlash->readMcs(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -655,7 +655,7 @@ void TrxBoard::setProbeDependParams(ScenPrbDepHardwareParam& prbDepParams) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    /////////////////////////// DSP setting ///////////////////////////
 | 
					 | 
					 | 
					    /////////////////////////// DSP setting ///////////////////////////
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbDepParams.prbDepParams.apodizationLut.size() != APODIZATIONLUT_LUT_MAX) | 
					 | 
					 | 
					    if(prbDepParams.prbDepParams.apodizationLut.size() != APODIZATIONLUT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Apodization lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Apodization lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->_beamFormerSlave0->apodizationLut(prbDepParams.prbDepParams.apodizationLut); | 
					 | 
					 | 
					    this->_beamFormerSlave0->apodizationLut(prbDepParams.prbDepParams.apodizationLut); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->_beamFormerSlave1->apodizationLut(prbDepParams.prbDepParams.apodizationLut); | 
					 | 
					 | 
					    this->_beamFormerSlave1->apodizationLut(prbDepParams.prbDepParams.apodizationLut); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -664,7 +664,7 @@ void TrxBoard::setProbeDependParams(ScenPrbDepHardwareParam& prbDepParams) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbDepParams.prbDepParams.atgcLut.size() != ATGC_LUT_MAX) | 
					 | 
					 | 
					    if(prbDepParams.prbDepParams.atgcLut.size() != ATGC_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Atgc lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Atgc lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->_dsp->atgcLut(prbDepParams.prbDepParams.atgcLut); | 
					 | 
					 | 
					    this->_dsp->atgcLut(prbDepParams.prbDepParams.atgcLut); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -685,109 +685,109 @@ void TrxBoard::setScenario(ScenHardware& scenGenHw) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.focusTypeNumber > FOCUS_TYPE_NUMBER_MAX) | 
					 | 
					 | 
					    if(scenGenHw.focusTypeNumber > FOCUS_TYPE_NUMBER_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Focus type number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Focus type number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->focusTypeNumber = scenGenHw.focusTypeNumber; | 
					 | 
					 | 
					    _scenParams->focusTypeNumber = scenGenHw.focusTypeNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.totalTxShotNumber > TOTAL_TX_SHOT_NUMBER_MAX) | 
					 | 
					 | 
					    if(scenGenHw.totalTxShotNumber > TOTAL_TX_SHOT_NUMBER_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Total tx shot number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Total tx-shot number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->totalTxShotNumber = scenGenHw.totalTxShotNumber; | 
					 | 
					 | 
					    _scenParams->totalTxShotNumber = scenGenHw.totalTxShotNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.rxBeamFormerNumber.size() > RX_BEAMFORMER_NUMBER_MAX) | 
					 | 
					 | 
					    if(scenGenHw.rxBeamFormerNumber.size() > RX_BEAMFORMER_NUMBER_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Rx beam former number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Rx beamformer number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->rxBeamFormerNumber = scenGenHw.rxBeamFormerNumber; | 
					 | 
					 | 
					    _scenParams->rxBeamFormerNumber = scenGenHw.rxBeamFormerNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex > SCENARIO_INDEX_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex > SCENARIO_INDEX_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Scenario end index is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Scenario end index is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex < scenGenHw.hwRegister.scenarioStartIndex) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex < scenGenHw.hwRegister.scenarioStartIndex) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException( | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					                  "The scenario end index must be greater than or equal to the scenario start index"); | 
					 | 
					 | 
					                  "The scenario end index must be greater than or equal to the scenario start index."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex != (scenGenHw.totalTxShotNumber - 1)) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.scenarioEndIndex != (scenGenHw.totalTxShotNumber - 1)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException( | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, | 
				
			
			
				
				
			
		
	
		
		
			
				
					
					 | 
					 | 
					                  "The scenario end index must be equal to the total tx shot number minus one"); | 
					 | 
					 | 
					                  "The scenario end index must be equal to the total tx-shot number minus one."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->scenarioStartIndex = scenGenHw.hwRegister.scenarioStartIndex; | 
					 | 
					 | 
					    _scenParams->scenarioStartIndex = scenGenHw.hwRegister.scenarioStartIndex; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->scenarioEndIndex = scenGenHw.hwRegister.scenarioEndIndex; | 
					 | 
					 | 
					    _scenParams->scenarioEndIndex = scenGenHw.hwRegister.scenarioEndIndex; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.blendWeight.size() != BLENDWEIGHT_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.blendWeight.size() != BLENDWEIGHT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Blend weight lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Blend weight lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->blendWeight = scenGenHw.hwRegister.blendWeight; | 
					 | 
					 | 
					    _scenParams->hwRegister->blendWeight = scenGenHw.hwRegister.blendWeight; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementXPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementXPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Element position x is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Element position x is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->xPosition = scenGenHw.hwRegister.elementXPosition; | 
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->xPosition = scenGenHw.hwRegister.elementXPosition; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementYPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementYPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Element position y is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Element position y is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->yPosition = scenGenHw.hwRegister.elementYPosition; | 
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->yPosition = scenGenHw.hwRegister.elementYPosition; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementZPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.elementZPosition.size() != ELEMENT_POSITION_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Element position z is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Element position z is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->zPosition = scenGenHw.hwRegister.elementZPosition; | 
					 | 
					 | 
					    _scenParams->hwRegister->elementPosition->zPosition = scenGenHw.hwRegister.elementZPosition; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					//if(scenGenHw.hwRegister.freqLut.size() != FREQUENCY_LUT_MAX)
 | 
					 | 
					 | 
					//if(scenGenHw.hwRegister.freqLut.size() != FREQUENCY_LUT_MAX)
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					//{
 | 
					 | 
					 | 
					//{
 | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					//throw SonoException("Frequency lut is out of range");
 | 
					 | 
					 | 
					//throw HardwareException(SCN_ERROR, "Frequency lut is out of range.");
 | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					//}
 | 
					 | 
					 | 
					//}
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					//_scenParams->hwRegister->freqLut = scenGenHw.hwRegister.freqLut;
 | 
					 | 
					 | 
					//_scenParams->hwRegister->freqLut = scenGenHw.hwRegister.freqLut;
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.dtgcLut.size() != DTGC_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.dtgcLut.size() != DTGC_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Dtgc lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Dtgc lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->dtgcLut = scenGenHw.hwRegister.dtgcLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->dtgcLut = scenGenHw.hwRegister.dtgcLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.dualPathWeight.size() != DUAL_PATH_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.dualPathWeight.size() != DUAL_PATH_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Dual path weight is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Dual path weight is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->dualPathWeight = scenGenHw.hwRegister.dualPathWeight; | 
					 | 
					 | 
					    _scenParams->hwRegister->dualPathWeight = scenGenHw.hwRegister.dualPathWeight; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.pulseTypeNumber > PULSE_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.pulseTypeNumber > PULSE_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Pulse type number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Pulse type number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->pulseTypeNumber = scenGenHw.hwRegister.pulseTypeNumber; | 
					 | 
					 | 
					    _scenParams->hwRegister->pulseTypeNumber = scenGenHw.hwRegister.pulseTypeNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.rxBeamFormerTypeNumber > RXBEAMFORMER_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.rxBeamFormerTypeNumber > RXBEAMFORMER_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Rx beam former type number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Rx beamformer type number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->rxBeamFormerTypeNumber = scenGenHw.hwRegister.rxBeamFormerTypeNumber; | 
					 | 
					 | 
					    _scenParams->hwRegister->rxBeamFormerTypeNumber = scenGenHw.hwRegister.rxBeamFormerTypeNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.receiverConfigTypeNumber > RRECEIVER_CONFIGURATION_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.receiverConfigTypeNumber > RRECEIVER_CONFIGURATION_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Receiver config type number is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Receiver config type number is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->receiverConfigTypeNumber = | 
					 | 
					 | 
					    _scenParams->hwRegister->receiverConfigTypeNumber = | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        scenGenHw.hwRegister.receiverConfigTypeNumber; | 
					 | 
					 | 
					        scenGenHw.hwRegister.receiverConfigTypeNumber; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startLpf.size() != LPF_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startLpf.size() != LPF_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Start lpf lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Start lpf lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endLpf.size() != LPF_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endLpf.size() != LPF_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("End lpf lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "End lpf lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->lpfLut.clear(); | 
					 | 
					 | 
					    _scenParams->hwRegister->lpfLut.clear(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -801,29 +801,29 @@ void TrxBoard::setScenario(ScenHardware& scenGenHw) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.lpfScale.size() != LPF_SCALE_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.lpfScale.size() != LPF_SCALE_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Lpf scale coefficient is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Lpf scale coefficient is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->lpfScaleCoeff = scenGenHw.hwRegister.ddcParams.lpfScale; | 
					 | 
					 | 
					    _scenParams->hwRegister->lpfScaleCoeff = scenGenHw.hwRegister.ddcParams.lpfScale; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startFreqLut.size() != START_FREQ_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startFreqLut.size() != START_FREQ_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Start freq lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Start freq lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->startFreqLut = scenGenHw.hwRegister.ddcParams.startFreqLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->startFreqLut = scenGenHw.hwRegister.ddcParams.startFreqLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endFreqLut.size() != END_FREQ_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endFreqLut.size() != END_FREQ_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("End freq lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "End freq lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->endFreqLut = scenGenHw.hwRegister.ddcParams.endFreqLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->endFreqLut = scenGenHw.hwRegister.ddcParams.endFreqLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startFreqPoint.size() != FREQ_POINT_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startFreqPoint.size() != FREQ_POINT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Start freq point lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Start freq point lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endFreqPoint.size() != FREQ_POINT_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.endFreqPoint.size() != FREQ_POINT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("End freq point lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "End freq point lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->freqPoint->clear(); | 
					 | 
					 | 
					    _scenParams->hwRegister->freqPoint->clear(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -837,25 +837,25 @@ void TrxBoard::setScenario(ScenHardware& scenGenHw) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.freqStepLut.size() != FREQ_STEP_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.freqStepLut.size() != FREQ_STEP_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Freq step lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Freq step lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->freqStepLut = scenGenHw.hwRegister.ddcParams.freqStepLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->freqStepLut = scenGenHw.hwRegister.ddcParams.freqStepLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.lpfWeightStepLut.size() != LPF_WEIGHT_STEP_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.lpfWeightStepLut.size() != LPF_WEIGHT_STEP_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Lpf weight step lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Lpf weight step lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->lpfWeightStepLut = scenGenHw.hwRegister.ddcParams.lpfWeightStepLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->lpfWeightStepLut = scenGenHw.hwRegister.ddcParams.lpfWeightStepLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startLpfWeightLut.size() != START_LPF_WEIGHT_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.ddcParams.startLpfWeightLut.size() != START_LPF_WEIGHT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Lpf weight step lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Lpf weight step lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->startLpfWeightLut = scenGenHw.hwRegister.ddcParams.startLpfWeightLut; | 
					 | 
					 | 
					    _scenParams->hwRegister->startLpfWeightLut = scenGenHw.hwRegister.ddcParams.startLpfWeightLut; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(scenGenHw.hwRegister.apodizationParams.winOpenStartPoint.size() > RXBEAMFORMER_LUT_MAX) | 
					 | 
					 | 
					    if(scenGenHw.hwRegister.apodizationParams.winOpenStartPoint.size() > RXBEAMFORMER_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Apodization parameters is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Apodization parameters are out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _scenParams->hwRegister->apodizationParams.clear(); | 
					 | 
					 | 
					    _scenParams->hwRegister->apodizationParams.clear(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1172,7 +1172,7 @@ void TrxBoard::setLineFilterCoefficient(QVector<float>& lineFilterLut) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(lineFilterLut.size() != LINE_FILTER_LUT_MAX) | 
					 | 
					 | 
					    if(lineFilterLut.size() != LINE_FILTER_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Line filter lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(SCN_ERROR, "Line filter lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _unsignedQntzrVec = Calculation::qntzr(lineFilterLut, 0, 9, 8, 0, true, false); | 
					 | 
					 | 
					    _unsignedQntzrVec = Calculation::qntzr(lineFilterLut, 0, 9, 8, 0, true, false); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QList<quint32> lineFilterLutQ = _unsignedQntzrVec.toList(); | 
					 | 
					 | 
					    QList<quint32> lineFilterLutQ = _unsignedQntzrVec.toList(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -1183,7 +1183,7 @@ void TrxBoard::setStbCoefficient(QVector<quint32>& stbLut) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(stbLut.size() != STB_COEFFICIENT_LUT_MAX) | 
					 | 
					 | 
					    if(stbLut.size() != STB_COEFFICIENT_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Stb lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(STB_ERROR, "Stb lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						QList<quint32> stbLutQ = stbLut.toList(); | 
					 | 
					 | 
						QList<quint32> stbLutQ = stbLut.toList(); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						this->_dsp->stbCoefficient(stbLutQ); | 
					 | 
					 | 
						this->_dsp->stbCoefficient(stbLutQ); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -1198,7 +1198,7 @@ void TrxBoard::setDtgcLut(QVector<float>& dtgcLut) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(dtgcLut.size() != DTGC_LUT_MAX) | 
					 | 
					 | 
					    if(dtgcLut.size() != DTGC_LUT_MAX) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Dtgc lut is out of range"); | 
					 | 
					 | 
					        throw HardwareException(DTGC_ERROR, "Dtgc lut is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    _unsignedQntzrVec = Calculation::qntzr(dtgcLut, 0, 12, 8, 0, true, false); | 
					 | 
					 | 
					    _unsignedQntzrVec = Calculation::qntzr(dtgcLut, 0, 12, 8, 0, true, false); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QList<quint32> dtgcLutQ = _unsignedQntzrVec.toList(); | 
					 | 
					 | 
					    QList<quint32> dtgcLutQ = _unsignedQntzrVec.toList(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -1213,12 +1213,12 @@ void TrxBoard::setFramesMetaData(const QByteArray& metaData) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    qint32 metaLength = metaData.length(); | 
					 | 
					 | 
					    qint32 metaLength = metaData.length(); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!metaLength) | 
					 | 
					 | 
					    if(!metaLength) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Meta data array is empty."); | 
					 | 
					 | 
					        throw HardwareException(SCEN_SRAM_ERROR, "Meta data array is empty."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(static_cast<quint32>(metaLength) > META_DATA_LENGTH * 8) | 
					 | 
					 | 
					    if(static_cast<quint32>(metaLength) > META_DATA_LENGTH * 8) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Meta data byte array is out of range."); | 
					 | 
					 | 
					        throw HardwareException(SCEN_SRAM_ERROR, "Meta data byte array is out of range."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QList<quint64> clear; | 
					 | 
					 | 
					    QList<quint64> clear; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1302,7 +1302,7 @@ void TrxBoard::setScenarioCompare(const QString scenPath) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!sramFile.open(QIODevice::WriteOnly)) | 
					 | 
					 | 
					    if(!sramFile.open(QIODevice::WriteOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't create the sram binary file due to the wrong path probably."); | 
					 | 
					 | 
					        throw HardwareException(SRAM_CMP_ERROR, "Couldn't create the sram binary file due to the wrong path probably."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    quint32 num(0); | 
					 | 
					 | 
					    quint32 num(0); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -1328,7 +1328,7 @@ void TrxBoard::setScenarioCompare(const QString scenPath) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!csvReadFile.open(QFile::ReadOnly)) | 
					 | 
					 | 
					    if(!csvReadFile.open(QFile::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException( | 
					 | 
					 | 
					        throw HardwareException(SRAM_CMP_ERROR, | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					                  "Could not open the register's scenario params due to the wrong path probably."); | 
					 | 
					 | 
					                  "Could not open the register's scenario params due to the wrong path probably."); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -1338,7 +1338,7 @@ void TrxBoard::setScenarioCompare(const QString scenPath) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!csvWriteFile.open(QFile::WriteOnly)) | 
					 | 
					 | 
					    if(!csvWriteFile.open(QFile::WriteOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException( | 
					 | 
					 | 
					        throw HardwareException(SRAM_CMP_ERROR, | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					                  "Couldn't create the register compare file due to the wrong path probably."); | 
					 | 
					 | 
					                  "Couldn't create the register compare file due to the wrong path probably."); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1387,7 +1387,7 @@ void TrxBoard::setScenarioCompare(const QString scenPath) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!sramReadFile.open(QFile::ReadOnly)) | 
					 | 
					 | 
					    if(!sramReadFile.open(QFile::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException( | 
					 | 
					 | 
					        throw HardwareException(SRAM_CMP_ERROR, | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					                  "Could not open the sram's scenario params due to the wrong path probably."); | 
					 | 
					 | 
					                  "Could not open the sram's scenario params due to the wrong path probably."); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1414,7 +1414,7 @@ void TrxBoard::setScenarioCompare(const QString scenPath) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(boardValue != fileValue) | 
					 | 
					 | 
					        if(boardValue != fileValue) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("The sram scenario file is different to the sram params of board."); | 
					 | 
					 | 
					            throw HardwareException(SRAM_CMP_ERROR, "The sram scenario file is different to the sram params of board."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        temp.clear(); | 
					 | 
					 | 
					        temp.clear(); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        num += sizeof(quint64); | 
					 | 
					 | 
					        num += sizeof(quint64); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1586,11 +1586,10 @@ void TrxBoard::scenPlayerStart(int count, bool afeHvPwrOn) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        _run = true; | 
					 | 
					 | 
					        _run = true; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        QtConcurrent::run(this, &TrxBoard::readLimitedData, count); | 
					 | 
					 | 
					        QtConcurrent::run(this, &TrxBoard::readLimitedData, count); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        //QtConcurrent::run(this, &TrxBoard::sendPacket);
 | 
					 | 
					 | 
					 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    else | 
					 | 
					 | 
					    else | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Total scenario luts and sram parameters are not written compeletely"); | 
					 | 
					 | 
					        throw HardwareException(SCEN_START_ERROR, "Total scenario luts and sram parameters have not written compeletely."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1732,11 +1731,10 @@ void TrxBoard::scenPlayerStart(bool unfreezeWithoutScenChanging) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        _run = true; | 
					 | 
					 | 
					        _run = true; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        QtConcurrent::run(this, &TrxBoard::readData); | 
					 | 
					 | 
					        QtConcurrent::run(this, &TrxBoard::readData); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        //QtConcurrent::run(this, &TrxBoard::sendPacket);
 | 
					 | 
					 | 
					 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    else | 
					 | 
					 | 
					    else | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Total scenario luts and sram parameters are not written compeletely"); | 
					 | 
					 | 
					        throw HardwareException(SCEN_START_ERROR, "Total scenario luts and sram parameters have not written compeletely."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1804,12 +1802,12 @@ void TrxBoard::fillRam(QString path) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(emulFile.fileName().isEmpty()) | 
					 | 
					 | 
					    if(emulFile.fileName().isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(EMU_DMA_ERROR, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!emulFile.open(QIODevice::ReadOnly)) | 
					 | 
					 | 
					    if(!emulFile.open(QIODevice::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open frame file to emulator test"); | 
					 | 
					 | 
					        throw HardwareException(EMU_DMA_ERROR, "Couldn't open frame file to emulator test."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    sramData = emulFile.readAll(); | 
					 | 
					 | 
					    sramData = emulFile.readAll(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1889,7 +1887,7 @@ void TrxBoard::systemCompare(QList<quint32> ¤tSystem, QList<QList<quint32> | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					            return; | 
					 | 
					 | 
					            return; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					    throw SonoException("The system parameters are not compatible."); | 
					 | 
					 | 
					    throw HardwareException(TRX_READ_FAILED, "The system parameters are not compatible."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					void TrxBoard::checkSystemCompatibility(QList<systemE2proms> &systemLut) | 
					 | 
					 | 
					void TrxBoard::checkSystemCompatibility(QList<systemE2proms> &systemLut) | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1947,7 +1945,7 @@ void TrxBoard::crcCheck(const QByteArray array, quint8 crcRom) const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    quint8 crcGen = crcGenerator(array); | 
					 | 
					 | 
					    quint8 crcGen = crcGenerator(array); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(crcGen != crcRom) | 
					 | 
					 | 
					    if(crcGen != crcRom) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("CRC check error is happend."); | 
					 | 
					 | 
					        throw HardwareException(PROBE_CRC_ERROR, "CRC check error happend."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -1974,7 +1972,7 @@ QByteArray TrxBoard::trxRomHeader() const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->trxEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->trxEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(headerArray != header) | 
					 | 
					 | 
					    if(headerArray != header) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("The header checksum of the TRX e2prom is corrupted."); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "The header checksum of the TRX e2prom corrupted."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    return header; | 
					 | 
					 | 
					    return header; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -2061,7 +2059,7 @@ QByteArray TrxBoard::mpsRomHeader() const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->mpsEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->mpsEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(headerArray != header) | 
					 | 
					 | 
					    if(headerArray != header) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("The header checksum of the MPS e2prom is corrupted."); | 
					 | 
					 | 
					        throw HardwareException(MPS_READ_FAILED, "The header checksum of the MPS e2prom corrupted."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    return header; | 
					 | 
					 | 
					    return header; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -2148,7 +2146,7 @@ QByteArray TrxBoard::prbCtrlRomHeader() const | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
					 | 
					 | 
					    QByteArray header = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER)); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(headerArray != header) | 
					 | 
					 | 
					    if(headerArray != header) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("The header checksum of the relay e2prom is corrupted."); | 
					 | 
					 | 
					        throw HardwareException(RELAY_READ_FAILED, "The header checksum of the relay e2prom corrupted."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    return header; | 
					 | 
					 | 
					    return header; | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					} | 
					 | 
					 | 
					} | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -2219,22 +2217,22 @@ void TrxBoard::selectedPrbState(EepromStatus& romStatus, eSelectProbe prbSel) co | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    vec = this->_bCtrlMngt->getConnectedPrb(); | 
					 | 
					 | 
					    vec = this->_bCtrlMngt->getConnectedPrb(); | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbSel == prbA && !vec.at(0)) | 
					 | 
					 | 
					    if(prbSel == prbA && !vec.at(0)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("This probe is disconnected"); | 
					 | 
					 | 
					        throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbSel == prbB && !vec.at(1)) | 
					 | 
					 | 
					    if(prbSel == prbB && !vec.at(1)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("This probe is disconnected"); | 
					 | 
					 | 
					        throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbSel == prbC && !vec.at(2)) | 
					 | 
					 | 
					    if(prbSel == prbC && !vec.at(2)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("This probe is disconnected"); | 
					 | 
					 | 
					        throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(prbSel == prbD && !vec.at(3)) | 
					 | 
					 | 
					    if(prbSel == prbD && !vec.at(3)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("This probe is disconnected"); | 
					 | 
					 | 
					        throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    romStatus.ConnectionMode = connected; | 
					 | 
					 | 
					    romStatus.ConnectionMode = connected; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -2512,7 +2510,7 @@ void TrxBoard::setTrxFanRpm(const eFanPwm& fan, const quint8& dutyCyclePercent) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(dutyCyclePercent > 100) | 
					 | 
					 | 
					    if(dutyCyclePercent > 100) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Out of range for fan duty cycle."); | 
					 | 
					 | 
					        throw HardwareException(FAN_FAULT_DETECTED, "Out of range for fan duty cycle."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->_bCtrlMngt->setFanPwm(fan, dutyCyclePercent); | 
					 | 
					 | 
					    this->_bCtrlMngt->setFanPwm(fan, dutyCyclePercent); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -2522,7 +2520,7 @@ void TrxBoard::setRegulatorSyncClk(const eRegSync& regType, const regulatorSync& | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					{ | 
					 | 
					 | 
					{ | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(regSyncParams.halfPeriod > 8192) | 
					 | 
					 | 
					    if(regSyncParams.halfPeriod > 8192) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Out of range for PLL sync clk."); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "Out of range for PLL sync clk."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    this->_bCtrlMngt->setPllRefClk(regType, regSyncParams); | 
					 | 
					 | 
					    this->_bCtrlMngt->setPllRefClk(regType, regSyncParams); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -2534,12 +2532,12 @@ void TrxBoard::mcsProgram(QString path) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						if(mcsFile.fileName().isEmpty()) | 
					 | 
					 | 
						if(mcsFile.fileName().isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						{ | 
					 | 
					 | 
						{ | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
							throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
						} | 
					 | 
					 | 
						} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						if(!mcsFile.open(QIODevice::ReadOnly)) | 
					 | 
					 | 
						if(!mcsFile.open(QIODevice::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
						{ | 
					 | 
					 | 
						{ | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open BPI bin file programming"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "Couldn't open BPI bin file programming."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
						} | 
					 | 
					 | 
						} | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    QByteArray mcsFileData = mcsFile.readAll(); | 
					 | 
					 | 
					    QByteArray mcsFileData = mcsFile.readAll(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -2559,12 +2557,12 @@ void TrxBoard::spiFlashProgram(QString path) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(binFile.fileName().isEmpty()) | 
					 | 
					 | 
					    if(binFile.fileName().isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!binFile.open(QIODevice::ReadOnly)) | 
					 | 
					 | 
					    if(!binFile.open(QIODevice::ReadOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open SPI flash bin file programming"); | 
					 | 
					 | 
					        throw HardwareException(TRX_READ_FAILED, "Couldn't open SPI flash bin file programming."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    bin = binFile.readAll(); | 
					 | 
					 | 
					    bin = binFile.readAll(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
						
						
							
								
							
						
					 | 
					@ -2583,12 +2581,12 @@ void TrxBoard::spiFlashRead(QString path) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(path.isEmpty()) | 
					 | 
					 | 
					        if(path.isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("No file is selected"); | 
					 | 
					 | 
					            throw HardwareException(TRX_READ_FAILED, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        if(!binFile.open(QIODevice::WriteOnly)) | 
					 | 
					 | 
					        if(!binFile.open(QIODevice::WriteOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        { | 
					 | 
					 | 
					        { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					            throw SonoException("Couldn't open SPI bin file programming"); | 
					 | 
					 | 
					            throw HardwareException(TRX_READ_FAILED, "Couldn't open SPI bin file programming."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					        } | 
					 | 
					 | 
					        } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					        binArray = this->_spiFlash->readBin(); | 
					 | 
					 | 
					        binArray = this->_spiFlash->readBin(); | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
							
								
							
						
						
					 | 
					@ -2794,12 +2792,12 @@ void TrxBoard::adcLoggerStart(const QString path, const QString fileName) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(logPath.isEmpty()) | 
					 | 
					 | 
					    if(logPath.isEmpty()) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("No file is selected"); | 
					 | 
					 | 
					        throw HardwareException(AFE_ERROR, "No file has selected."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    if(!logFile.open(QIODevice::WriteOnly)) | 
					 | 
					 | 
					    if(!logFile.open(QIODevice::WriteOnly)) | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    { | 
					 | 
					 | 
					    { | 
				
			
			
		
	
		
		
			
				
					
					 | 
					 | 
					        throw SonoException("Couldn't open file for logging"); | 
					 | 
					 | 
					        throw HardwareException(AFE_ERROR, "Couldn't open file for logging."); | 
				
			
			
				
				
			
		
	
		
		
	
		
		
			
				
					 | 
					 | 
					    } | 
					 | 
					 | 
					    } | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					
 | 
					 | 
					 | 
					
 | 
				
			
			
		
	
		
		
			
				
					 | 
					 | 
					    log << "SYNC Offset(ns): "; | 
					 | 
					 | 
					    log << "SYNC Offset(ns): "; | 
				
			
			
		
	
	
		
		
			
				
					| 
						
							
								
							
						
						
						
					 | 
					
  |