mmtalaie
/
hardware-api
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
102 Commits
2 Branches
29 Tags
1.3 MiB
 
 
Tree: def19388b4
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'def19388b4'
${ noResults }
hardware-api/src/model/hardware/core/lowLevelApi/TrxBoard.cpp

2959 lines
90 KiB
Raw Blame History

#include "model/hardware/core/lowLevelApi/TrxBoard.h"
template<class T>
QByteArray TrxBoard::uintLittleEndian2ByteArray(T& data) const
{
QByteArray byte;
QDataStream out(&byte, QIODevice::WriteOnly);
out.setByteOrder(QDataStream::LittleEndian);
out << data;
return byte;
}
template<class T>
T TrxBoard::byteArray2UintLittleEndian(QByteArray& byte) const
{
T data;
QDataStream in(byte);
in.setByteOrder(QDataStream::LittleEndian);
in >> data;
return data;
}
void TrxBoard::sonoLiveTimeout()
{
_sonoHeartBeats = !_sonoHeartBeats;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
}
void TrxBoard::sonoHeartBeatsEnable() const
{
this->_scenPlayer->control.heartBeatsDisable(false);
this->afesHeartBeatDisable(false);
}
void TrxBoard::sonoHeartBeatsDisable(void) const
{
this->_scenPlayer->control.heartBeatsDisable(true);
this->afesHeartBeatDisable(true);
}
//void TrxBoard::sendPacket()
//{
// auto counter(0);
// while(_run)
// {
// if(_swCounter == 0)
// {
// std::this_thread::sleep_for(std::chrono::milliseconds(3));
// continue;
// }
// else if(_swCounter != counter)
// {
// auto framePacket = QByteArray::fromRawData(_device.getBufferPtr(counter), BUFFER_SIZE);
//#ifdef DEVELOP_UI
// emit sendFramePacket(framePacket);
//#else
// packetEngine.newData(framePacket);
//#endif
// counter++;
// if(counter >= SW_BUFFER_NUM)
// {
// counter = 0;
// }
// }
// }
//}
void TrxBoard::readData()
{
_swCounter = _device.getCounter();
while(_run)
{
auto cnt = _device.getCounter();
if(cnt == 0)
{
_hwCounter = 0;
//std::this_thread::sleep_for(std::chrono::milliseconds(3));
continue;
}
else if(cnt != _hwCounter)
{
_hwCounter++;
if(_hwCounter > HW_BUFFER_NUM)
{
_hwCounter = 1;
}
_device.copy(_hwCounter - 1, _swCounter);
auto framePacket =
QByteArray::fromRawData(_device.getBufferPtr(_swCounter), BUFFER_SIZE);
auto batch = ((static_cast<quint16>(framePacket[128])) & 0x00FF) |
(((static_cast<quint16>(framePacket[129])) << 8) & 0xFF00);
auto subBbatch = ((static_cast<quint16>(framePacket[130])) & 0x00FF);
if((batch == preBatch && subBbatch - preSubBatch != 1) ||
(preSubBatch == -1 && (batch != 0 || subBbatch != 0)) ||
(batch - preBatch > 1) ||
(batch - preBatch == 1 && subBbatch != 0))
{
throw HardwareException(DMA_XFER_ERROR, "Batch/subBatch id error occured.");
}
preBatch = batch;
preSubBatch = subBbatch;
#ifdef DEVELOP_UI
emit sendFramePacket(framePacket);
#else
packetEngine.newData(framePacket);
#endif
_swCounter++;
if(_swCounter >= SW_BUFFER_NUM)
{
_swCounter = 0;
}
}
}
}
void TrxBoard::sramClear(eSramClear clearMode)
{
quint32 num(0);
if(clearMode == all)
{
while(num < SRAM_SIZE)
{
this->_device.device.writeLong(BAR_SRAM, static_cast<quint32>(num), 0);
num += sizeof(quint64);
}
}
if(clearMode == first4M)
{
while(num < SRAM_SIZE / 4)
{
this->_device.device.writeLong(BAR_SRAM, static_cast<quint32>(num), 0);
num += sizeof(quint64);
}
}
}
void TrxBoard::scenParamsFilling(TrxBoard::eScenParams cmd)
{
static quint8 scenParams = 0;
scenParams = cmd ? (scenParams + cmd) : (cmd);
if(scenParams >= TOTAL_SCEN_LUT_SRAM)
{
scenParams = TOTAL_SCEN_LUT_SRAM;
_allow = true;
}
else
{
_allow = false;
}
}
void TrxBoard::afeAdcsSync(const quint8& slaveMounted)
{
auto afeSyncStatus = [this](Afe* Slave)
{
this->_bCtrlMngt->timerShot(1);
while(!(Slave->getAfeSyncDone()))
{
if(this->_bCtrlMngt->checkTimeout())
{
throw HardwareException(AFE_ERROR,
"The timeout of the afe adcs sync happend without receiving of sync done.");
}
}
this->_bCtrlMngt->timerStop();
if(MOUNTED_SLAVE_FPGA == 7)
{
quint32 syncErr = Slave->getAfeSyncError();
if(syncErr != 0)
{
throw HardwareException(AFE_ERROR,
"The error of the afe adcs sync happend.");
}
}
};
this->delay(20);
this->_misc->setSyncMode(adcSyncMode);
this->_misc->setManualSync(true);
this->_misc->setManualSync(false);
this->_misc->setManualSync(bfSyncMode);
if(slaveMounted & 1)
{
afeSyncStatus(_afeSlave0);
}
if(slaveMounted & 2)
{
afeSyncStatus(_afeSlave1);
}
if(slaveMounted & 4)
{
afeSyncStatus(_afeSlave2);
}
}
void TrxBoard::waitForCaptureDone(Debug* _dbg)
{
//Timeout to receive adc capture done.
this->_bCtrlMngt->timerShot(1000);
while(!(_dbg->getCapDone()))
{
if(this->_bCtrlMngt->checkTimeout())
{
throw HardwareException(AFE_ERROR, "Failure to receive adc capture done.");
}
}
this->_bCtrlMngt->timerStop();
}
void TrxBoard::adcCaptureStop(Debug* _dbg) const
{
_dbg->adcCaptureCmd(captureStop);
}
void TrxBoard::adcCaptureStart(Debug* _dbg) const
{
_dbg->adcCaptureCmd(captureStart);
}
void TrxBoard::adcLogTransferRoutine(Debug* _dbg, quint8 chNumPerFpga)
{
bool adcSamplerReady(false);
bool adcSamplerError(false);
//Adc logger start according to selected afe channel.
_dbg->adcLoggerTransferCmd(loggerStop);
_dbg->adcLoggerChannelNum(chNumPerFpga);
_dbg->adcLoggerTransferCmd(loggerStart);
//Timeout to receive adc log transfer done.
this->_bCtrlMngt->timerShot(20);
while(!(_dbg->getTransferDone()))
{
if(this->_bCtrlMngt->checkTimeout())
{
throw HardwareException(AFE_ERROR, "Failure to receive adc log transfer done.");
}
}
this->_bCtrlMngt->timerStop();
//Timeout to receive adc sampler done.
this->_bCtrlMngt->timerShot(20);
while(!adcSamplerReady && !adcSamplerError)
{
adcSamplerReady = this->_misc->getAdcSamplerBramReady();
adcSamplerError = this->_misc->getAdcSamplerError();
if(this->_bCtrlMngt->checkTimeout())
{
throw HardwareException(AFE_ERROR, "Failure to receive adc sampler done.");
}
}
this->_bCtrlMngt->timerStop();
if(adcSamplerError)
{
throw HardwareException(AFE_ERROR, "The adc sampler error occured.");
}
//Adc logger stop
_dbg->adcLoggerTransferCmd(loggerStop);
}
void TrxBoard::debuggerMode(Debug* _dbg, DebugMode& debug, DebugMode& debugRb, QString slaveN) const
{
_dbg->setDebuggerMode(debug);
_dbg->getDebuggerMode(debugRb);
if((debugRb.txBfTestModeEn != debug.txBfTestModeEn) ||
(debugRb.txBfTestModeCfg != debug.txBfTestModeCfg))
{
throw ("The debugger mode register configuration of " + slaveN + " is corrupted.");
}
}
void TrxBoard::setSwapVector()
{
_swapVec.clear();
_swapVec << 0 << 113 << 98 << 19 << 4 << 117 << 102 << 23 << 8 << 121 << 106 << 27
<< 12 << 125 << 110 << 31 << 16 << 1 << 114 << 99 << 20 << 5 << 118 << 103
<< 24 << 9 << 122 << 107 << 28 << 13 << 126 << 111 << 96 << 17 << 2 << 115
<< 100 << 21 << 6 << 119 << 104 << 25 << 10 << 123 << 108 << 29 << 14 << 127
<< 112 << 97 << 18 << 3 << 116 << 101 << 22 << 7 << 120 << 105 << 26 << 11
<< 124 << 109 << 30 << 15 << 32 << 145 << 130 << 51 << 36 << 149 << 134 << 55
<< 40 << 153 << 138 << 59 << 44 << 157 << 142 << 63 << 48 << 33 << 146 << 131
<< 52 << 37 << 150 << 135 << 56 << 41 << 154 << 139 << 60 << 45 << 158 << 143
<< 128 << 49 << 34 << 147 << 132 << 53 << 38 << 151 << 136 << 57 << 42 << 155
<< 140 << 61 << 46 << 159 << 144 << 129 << 50 << 35 << 148 << 133 << 54 << 39
<< 152 << 137 << 58 << 43 << 156 << 141 << 62 << 47 << 64 << 177 << 162 << 83
<< 68 << 181 << 166 << 87 << 72 << 185 << 170 << 91 << 76 << 189 << 174 << 95
<< 80 << 65 << 178 << 163 << 84 << 69 << 182 << 167 << 88 << 73 << 186 << 171
<< 92 << 77 << 190 << 175 << 160 << 81 << 66 << 179 << 164 << 85 << 70 << 183
<< 168 << 89 << 74 << 187 << 172 << 93 << 78 << 191 << 176 << 161 << 82 << 67
<< 180 << 165 << 86 << 71 << 184 << 169 << 90 << 75 << 188 << 173 << 94 << 79;
}
void TrxBoard::setRomCrc()
{
unsigned char crcArray[] = {0x4, 0x0, 0x13, 0x0, 0x27, 0x0, 0x28, 0x0, 0xEB, 0x1,
0xAC, 0x5, 0xAC, 0x6, 0x4C, 0x6, 0xB0, 0x6, 0xB2};
for(auto var : crcArray)
{
_eepromCrc.push_back(static_cast<char>(var));
}
}
void TrxBoard::setAfeModuleOffset()
{
_afeModuleOffset.clear();
_afeModuleOffset << 0x1000 << 0x2000 << 0x4000 << 0x8000;
}
void TrxBoard::setFpgaOffset()
{
_fpgaOffset.clear();
_fpgaOffset << 0x100000 << 0x200000 << 0x300000;
}
QList<quint32> TrxBoard::systemStructure2List(systemE2proms &systemRoms)
{
QList<quint32> dataset;
dataset.append(systemRoms.trx.id);
dataset.append(systemRoms.prbCtrl.id);
dataset.append(systemRoms.mps.id);
dataset.append(systemRoms.trx.pid);
dataset.append(systemRoms.prbCtrl.pid);
dataset.append(systemRoms.mps.pid);
dataset.append(systemRoms.trx.pcbVersion);
dataset.append(systemRoms.prbCtrl.pcbVersion);
dataset.append(systemRoms.mps.pcbVersion);
dataset.append(systemRoms.trx.firstMbedCodeVersion);
dataset.append(systemRoms.mps.firstMbedCodeVersion);
dataset.append(systemRoms.trx.secondMbedCodeVersion);
dataset.append(systemRoms.mps.secondMbedCodeVersion);
// dataset.append(systemRoms.fpgaCodeVersion.masterCode);
// dataset.append(systemRoms.fpgaCodeVersion.slave0Code);
// dataset.append(systemRoms.fpgaCodeVersion.slave1Code);
// dataset.append(systemRoms.fpgaCodeVersion.slave2Code);
return dataset;
}
//QList<quint32> TrxBoard::signedVector2unsignedList (QVector<qint32>& sgnVec)
//{
//_unsignedQntzrList.clear();
//// std::list<uint> _usgnList (sgnVec.begin(), sgnVec.end());
//// _unsignedQntzrList.fromStdList(_usgnList);
//foreach (auto i, sgnVec)
//{
//_unsignedQntzrList.push_back(static_cast<quint32>(i));
//}
//return _unsignedQntzrList;
//}
TrxBoard::TrxBoard() : _offsetSlave0(0), _offsetSlave1(0x400000), _offsetSlave2(0x800000)
{
_beamFormerSlave0 = new BeamFormer(&_device, _offsetSlave0);
_beamFormerSlave1 = new BeamFormer(&_device, _offsetSlave1);
_beamFormerSlave2 = new BeamFormer(&_device, _offsetSlave2);
_debugSlave0 = new Debug(&_device, _offsetSlave0);
_debugSlave1 = new Debug(&_device, _offsetSlave1);
_debugSlave2 = new Debug(&_device, _offsetSlave2);
_clkDistributer = new ClockDistributer(&_device);
_afeSlave0 = new Afe(&_device, _offsetSlave0);
_afeSlave1 = new Afe(&_device, _offsetSlave1);
_afeSlave2 = new Afe(&_device, _offsetSlave2);
_bCtrlMngt = new BoardsCtrlMngt(&_device);
_builtInTest = new BuiltInTest(&_device);
_fpgaProgram = new FpgaProgram(&_device);
_scenPlayer = new ScenPalyer(&_device);
_spiFlash = new SpiFlash(&_device);
_bpiFlash = new BpiFlash(&_device);
_emul = new Emulator(&_device);
_misc = new Misc(&_device);
_sram = new Sram(&_device);
_dsp = new Dsp(&_device);
_adc = new AdcVoltages;
_pg = new VoltagesPg;
_tachoRpm = new FanRpm;
_coreVolt = new criticalComponentVoltages;
_coreTemp = new criticalComponentTemperature;
_scenParams = new ScenGenHardwareParam;
_sonoLiveTimer = new QTimer;
connect(_sonoLiveTimer, &QTimer::timeout, this, &TrxBoard::sonoLiveTimeout);
_sonoHeartBeats = false;
_allow = false;
_run = false;
setSwapVector();
setRomCrc();
setFpgaOffset();
setAfeModuleOffset();
preSubBatch = -1;
preBatch = 0;
}
TrxBoard::ScenHwRegister::ScenHwRegister()
{
elementPosition = new ProbeElementPosition;
rxBeamformer = new RxBeamformerProperties;
configLut = new ReceiverConfiguration;
freqPoint = new FreqPoint;
pulse = new PulseProperties;
}
TrxBoard::ScenGenHardwareParam::ScenGenHardwareParam()
{
hwRegister = new ScenHwRegister;
indexParams = new SramIndex;
rxParams = new SramRx;
txParams = new SramTx;
}
TrxBoard::~TrxBoard()
{
delete _beamFormerSlave0;
delete _beamFormerSlave1;
delete _beamFormerSlave2;
delete _clkDistributer;
delete _debugSlave0;
delete _debugSlave1;
delete _debugSlave2;
delete _fpgaProgram;
delete _builtInTest;
delete _scenPlayer;
delete _afeSlave0;
delete _afeSlave1;
delete _afeSlave2;
delete _bCtrlMngt;
delete _spiFlash;
delete _bpiFlash;
delete _emul;
delete _misc;
delete _sram;
delete _dsp;
delete _adc;
delete _pg;
delete _tachoRpm;
delete _coreVolt;
delete _coreTemp;
delete _scenParams;
delete _sonoLiveTimer;
}
TrxBoard::ScenHwRegister::~ScenHwRegister()
{
delete elementPosition;
delete rxBeamformer;
delete configLut;
delete freqPoint;
delete pulse;
}
TrxBoard::ScenGenHardwareParam::~ScenGenHardwareParam()
{
delete indexParams;
delete hwRegister;
delete rxParams;
delete txParams;
}
void TrxBoard::init(bool reset)
{
this->_device.init();
this->_bCtrlMngt->prbCtrlInit();
if(!reset)
{
return;
}
#ifdef MPS_BOARD
mpsReset();
#endif
sramClear(all);
}
void TrxBoard::delay(quint16 ms) const
{
this->_bCtrlMngt->timerShot(ms);
//uncrustify off
while(!(this->_bCtrlMngt->checkTimeout()));
//uncrustify on
}
void TrxBoard::fpgaProgram(const QString path, const quint8& slaveMounted) const
{
if(slaveMounted <= 0 || slaveMounted >= 8)
{
throw HardwareException(SLAVE_PROG_FAILED, "Wrong mounted slave fpga has selected.");
}
QByteArray bitFileData;
QFile bitFile(path);
bitFileData.clear();
if(bitFile.fileName().isEmpty())
{
throw HardwareException(SLAVE_PROG_FAILED, "No file has selected.");
}
if(!bitFile.open(QIODevice::ReadOnly))
{
throw HardwareException(SLAVE_PROG_FAILED, "Couldn't open bit file programming.");
}
bitFileData = bitFile.readAll();
bitFile.close();
this->_fpgaProgram->program(bitFileData, slaveMounted);
}
void TrxBoard::gtReadReset()
{
QList<bool> errorList;
bool error(false);
QList<quint32> offsetRd = {0x14008 * 4, 0x114008 * 4, 0x214008 * 4, 0x314008 * 4,
0x1400B * 4, 0x11400B * 4, 0x21400B * 4, 0x31400B * 4,
0x1400C * 4, 0x11400C * 4, 0x21400C * 4, 0x31400C * 4,
0x1400D * 4, 0x11400D * 4, 0x21400D * 4, 0x31400D * 4,
0x14010 * 4, 0x114010 * 4, 0x214010 * 4, 0x314010 * 4,
0x14011 * 4, 0x114011 * 4, 0x214011 * 4, 0x314011 * 4};
QList<quint32> correctVal = {0x0, 0xFF43, 0xFF43, 0xFF43,
0x0, 0xFFFF, 0xFFFF, 0xFFFF,
0x0, 0xF0F, 0xF0F, 0xF0F,
0xFF43, 0xF04F, 0xFF43, 0xFF43,
0xFFFF, 0xFF00, 0xFFFF, 0xFFFF,
0xF0F, 0xF00, 0xF0F, 0xF0F};
/**************************** GT Read ****************************/
for(auto i = 0; i < 24; i++)
{
quint32 value = this->_device.device.readWord(BAR_REG, offsetRd.at(i));
if(value == correctVal.at(i))
{
errorList.append(false);
}
else
{
errorList.append(true);
}
}
foreach(auto& er, errorList)
{
error |= er;
}
if(error && MOUNTED_SLAVE_FPGA == 7)
{
/*************************** GT Reset ***************************/
QList<quint32> resetAddr;
resetAddr << 0x14000 << 0x14003 << 0x114000 << 0x114003
<< 0x214000 << 0x214003 << 0x314000 << 0x314003;
for(auto value = 2; value >= 0; value--)
{
foreach(auto& offset, resetAddr)
{
this->_device.device.writeWord(BAR_REG, offset * 4, static_cast<quint32>(value));
}
}
/*************************** Delay (1s) ***************************/
this->delay(1000);
/**************************** GT Read *****************************/
for(auto i = 0; i < 24; i++)
{
quint32 value = this->_device.device.readWord(BAR_REG, offsetRd.at(i));
if(value == correctVal.at(i))
{
errorList.append(false);
}
else
{
errorList.append(true);
}
}
foreach(auto& er, errorList)
{
error |= er;
}
if(error)
{
throw HardwareException(SCEN_GT_ERROR, "The GT error happened and it didn't solve by gt reset.");
}
}
}
void TrxBoard::mcsRead(const QString path) const
{
QList<quint32> mcsList;
QByteArray byte;
quint32 value(0);
qint32 num(0);
QFile mcsFile(path + "/BPI_bin_rdback.bin");
if(path.isEmpty())
{
throw HardwareException(TRX_READ_FAILED, "No file has selected.");
}
if(!mcsFile.open(QIODevice::WriteOnly))
{
throw HardwareException(TRX_READ_FAILED, "Couldn't open BPI bin file programming.");
}
mcsList = this->_bpiFlash->readMcs();
while(num < BPI_FLASH_SIZE / 4)
{
value = mcsList[num];
byte = uintLittleEndian2ByteArray<quint32>(value);
mcsFile.write(byte);
byte.clear();
num++;
}
mcsFile.flush();
mcsFile.close();
}
void TrxBoard::setProbeDependParams(ScenPrbDepHardwareParam& prbDepParams)
{
/////////////////////////// AFE setting ///////////////////////////
setAfeConfig(prbDepParams.afeCfg);
// setAfesPwr(afePwrdnEnable);
// setAfesFastPwr(afePwrdnEnable);
}
void TrxBoard::setScenario(ScenHardware& scenGenHw)
{
if(this->_scenPlayer->control.getCommand())
{
scenPlayerStop();
}
emulatorStop();
sramClear(first4M);
if(scenGenHw.focusTypeNumber > FOCUS_TYPE_NUMBER_MAX)
{
throw HardwareException(SCN_ERROR, "Focus type number is out of range.");
}
_scenParams->focusTypeNumber = scenGenHw.focusTypeNumber;
if(scenGenHw.totalTxShotNumber > TOTAL_TX_SHOT_NUMBER_MAX)
{
throw HardwareException(SCN_ERROR, "Total tx-shot number is out of range.");
}
_scenParams->totalTxShotNumber = scenGenHw.totalTxShotNumber;
if(scenGenHw.rxBeamFormerNumber.size() > RX_BEAMFORMER_NUMBER_MAX)
{
throw HardwareException(SCN_ERROR, "Rx beamformer number is out of range.");
}
_scenParams->rxBeamFormerNumber = scenGenHw.rxBeamFormerNumber;
if(scenGenHw.hwRegister.scenarioEndIndex > SCENARIO_INDEX_MAX)
{
throw HardwareException(SCN_ERROR, "Scenario end index is out of range.");
}
if(scenGenHw.hwRegister.scenarioEndIndex < scenGenHw.hwRegister.scenarioStartIndex)
{
throw HardwareException(SCN_ERROR,
"The scenario end index must be greater than or equal to the scenario start index.");
}
if(scenGenHw.hwRegister.scenarioEndIndex != (scenGenHw.totalTxShotNumber - 1))
{
throw HardwareException(SCN_ERROR,
"The scenario end index must be equal to the total tx-shot number minus one.");
}
_scenParams->scenarioStartIndex = scenGenHw.hwRegister.scenarioStartIndex;
_scenParams->scenarioEndIndex = scenGenHw.hwRegister.scenarioEndIndex;
if(scenGenHw.hwRegister.blendWeight.size() != BLENDWEIGHT_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Blend weight lut is out of range.");
}
_scenParams->hwRegister->blendWeight = scenGenHw.hwRegister.blendWeight;
if(scenGenHw.hwRegister.elementXPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Element position x is out of range.");
}
_scenParams->hwRegister->elementPosition->xPosition = scenGenHw.hwRegister.elementXPosition;
if(scenGenHw.hwRegister.elementYPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Element position y is out of range.");
}
_scenParams->hwRegister->elementPosition->yPosition = scenGenHw.hwRegister.elementYPosition;
if(scenGenHw.hwRegister.elementZPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Element position z is out of range.");
}
_scenParams->hwRegister->elementPosition->zPosition = scenGenHw.hwRegister.elementZPosition;
//if(scenGenHw.hwRegister.freqLut.size() != FREQUENCY_LUT_MAX)
//{
//throw HardwareException(SCN_ERROR, "Frequency lut is out of range.");
//}
//_scenParams->hwRegister->freqLut = scenGenHw.hwRegister.freqLut;
if(scenGenHw.hwRegister.dtgcLut.size() != DTGC_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Dtgc lut is out of range.");
}
_scenParams->hwRegister->dtgcLut = scenGenHw.hwRegister.dtgcLut;
if(scenGenHw.hwRegister.dualPathWeight.size() != DUAL_PATH_MAX)
{
throw HardwareException(SCN_ERROR, "Dual path weight is out of range.");
}
_scenParams->hwRegister->dualPathWeight = scenGenHw.hwRegister.dualPathWeight;
if(scenGenHw.hwRegister.pulseTypeNumber > PULSE_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Pulse type number is out of range.");
}
_scenParams->hwRegister->pulseTypeNumber = scenGenHw.hwRegister.pulseTypeNumber;
if(scenGenHw.hwRegister.rxBeamFormerTypeNumber > RXBEAMFORMER_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Rx beamformer type number is out of range.");
}
_scenParams->hwRegister->rxBeamFormerTypeNumber = scenGenHw.hwRegister.rxBeamFormerTypeNumber;
if(scenGenHw.hwRegister.receiverConfigTypeNumber > RRECEIVER_CONFIGURATION_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Receiver config type number is out of range.");
}
_scenParams->hwRegister->receiverConfigTypeNumber =
scenGenHw.hwRegister.receiverConfigTypeNumber;
if(scenGenHw.hwRegister.ddcParams.startLpf.size() != LPF_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Start lpf lut is out of range.");
}
if(scenGenHw.hwRegister.ddcParams.endLpf.size() != LPF_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "End lpf lut is out of range.");
}
_scenParams->hwRegister->lpfLut.clear();
for(qint8 i = 0; i < LPF_LUT_MAX; i++)
{
Lpf lpfObj;
lpfObj.startLpf = scenGenHw.hwRegister.ddcParams.startLpf.at(i);
lpfObj.endLpf = scenGenHw.hwRegister.ddcParams.endLpf.at(i);
_scenParams->hwRegister->lpfLut.push_back(lpfObj);
}
if(scenGenHw.hwRegister.ddcParams.lpfScale.size() != LPF_SCALE_MAX)
{
throw HardwareException(SCN_ERROR, "Lpf scale coefficient is out of range.");
}
_scenParams->hwRegister->lpfScaleCoeff = scenGenHw.hwRegister.ddcParams.lpfScale;
if(scenGenHw.hwRegister.ddcParams.startFreqLut.size() != START_FREQ_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Start freq lut is out of range.");
}
_scenParams->hwRegister->startFreqLut = scenGenHw.hwRegister.ddcParams.startFreqLut;
if(scenGenHw.hwRegister.ddcParams.endFreqLut.size() != END_FREQ_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "End freq lut is out of range.");
}
_scenParams->hwRegister->endFreqLut = scenGenHw.hwRegister.ddcParams.endFreqLut;
if(scenGenHw.hwRegister.ddcParams.startFreqPoint.size() != FREQ_POINT_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Start freq point lut is out of range.");
}
if(scenGenHw.hwRegister.ddcParams.endFreqPoint.size() != FREQ_POINT_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "End freq point lut is out of range.");
}
_scenParams->hwRegister->freqPoint->clear();
for(qint8 i = 0; i < FREQ_POINT_LUT_MAX; i++)
{
_scenParams->hwRegister->freqPoint->startFreqPoint =
scenGenHw.hwRegister.ddcParams.startFreqPoint;
_scenParams->hwRegister->freqPoint->endFreqPoint =
scenGenHw.hwRegister.ddcParams.endFreqPoint;
}
if(scenGenHw.hwRegister.ddcParams.freqStepLut.size() != FREQ_STEP_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Freq step lut is out of range.");
}
_scenParams->hwRegister->freqStepLut = scenGenHw.hwRegister.ddcParams.freqStepLut;
if(scenGenHw.hwRegister.ddcParams.lpfWeightStepLut.size() != LPF_WEIGHT_STEP_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Lpf weight step lut is out of range.");
}
_scenParams->hwRegister->lpfWeightStepLut = scenGenHw.hwRegister.ddcParams.lpfWeightStepLut;
if(scenGenHw.hwRegister.ddcParams.startLpfWeightLut.size() != START_LPF_WEIGHT_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Lpf weight step lut is out of range.");
}
_scenParams->hwRegister->startLpfWeightLut = scenGenHw.hwRegister.ddcParams.startLpfWeightLut;
if(scenGenHw.hwRegister.apodizationParams.winOpenStartPoint.size() > RXBEAMFORMER_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Apodization parameters are out of range.");
}
_scenParams->hwRegister->apodizationParams.clear();
for(qint32 j = 0; j < scenGenHw.hwRegister.apodizationParams.winOpenStartPoint.size(); j++)
{
ApoParams params;
params.winOpenStepVal = scenGenHw.hwRegister.apodizationParams.winOpenStepVal.at(j);
params.winOpenStopVal = scenGenHw.hwRegister.apodizationParams.winOpenStopVal.at(j);
params.maxApertureSize = scenGenHw.hwRegister.apodizationParams.maxApertureSize.at(j);
params.minApertureSize = scenGenHw.hwRegister.apodizationParams.minApertureSize.at(j);
params.winOpenStartVal = scenGenHw.hwRegister.apodizationParams.winOpenStartVal.at(j);
params.winOpenStopPoint = scenGenHw.hwRegister.apodizationParams.winOpenStopPoint.at(j);
params.winOpenStartPoint = scenGenHw.hwRegister.apodizationParams.winOpenStartPoint.at(j);
params.rxActiveElementStep1 =
scenGenHw.hwRegister.apodizationParams.rxActiveElementStep1.at(j);
params.rxActiveElementStep2 =
scenGenHw.hwRegister.apodizationParams.rxActiveElementStep2.at(j);
params.rxActiveElementStepStopPoint =
scenGenHw.hwRegister.apodizationParams.rxActiveElementStepStopPoint.at(j);
params.rxActiveElementStepStartPoint =
scenGenHw.hwRegister.apodizationParams.rxActiveElementStepStartPoint.at(j);
params.rxActiveElementStepChangePoint =
scenGenHw.hwRegister.apodizationParams.rxActiveElementStepChangePoint.at(j);
_scenParams->hwRegister->apodizationParams.push_back(params);
}
_scenParams->hwRegister->pulse->clear();
foreach(auto i, scenGenHw.hwRegister.pulseProps)
{
_scenParams->hwRegister->pulse->halfPeriod.append(i.halfPeriod);
_scenParams->hwRegister->pulse->startPhase.append(i.startPhase);
_scenParams->hwRegister->pulse->halfCycleNo.append(i.halfCycleNo);
_scenParams->hwRegister->pulse->pulseVoltSel.append(i.pulseVoltSel);
_scenParams->hwRegister->pulse->dampingPulseWidth.append(i.dampingPulseWidth);
}
_scenParams->hwRegister->rxBeamformer->clear();
foreach(auto j, scenGenHw.hwRegister.rxBeamFormerProps)
{
_scenParams->hwRegister->rxBeamformer->lag.append(j.lag);
_scenParams->hwRegister->rxBeamformer->mla.append(j.mla);
_scenParams->hwRegister->rxBeamformer->apodization.append(j.apodizationSel);
}
_scenParams->hwRegister->configLut->clear();
foreach(auto k, scenGenHw.hwRegister.receiverConfigProps)
{
_scenParams->hwRegister->configLut->mla.append(k.mla);
_scenParams->hwRegister->configLut->stb.append(k.stb);
_scenParams->hwRegister->configLut->absEn.append(k.absEn);
_scenParams->hwRegister->configLut->ddcEn.append(k.ddcEn);
_scenParams->hwRegister->configLut->logEn.append(k.logEn);
_scenParams->hwRegister->configLut->stbEn.append(k.stbEn);
_scenParams->hwRegister->configLut->lpfSel.append(k.lpfSel);
_scenParams->hwRegister->configLut->dTgcEn.append(k.dTgcEn);
_scenParams->hwRegister->configLut->blendEn.append(k.blendEn);
_scenParams->hwRegister->configLut->aTgcSel.append(k.aTgcSel);
_scenParams->hwRegister->configLut->focusNo.append(k.focusNo);
_scenParams->hwRegister->configLut->lineMode.append(k.lineMode);
_scenParams->hwRegister->configLut->frameType.append(k.frameType);
_scenParams->hwRegister->configLut->ncoFreqSel.append(k.ncoFreqSel);
_scenParams->hwRegister->configLut->dualPathEn.append(k.dualPathEn);
_scenParams->hwRegister->configLut->dcCancelerEn.append(k.dcCancelEn);
_scenParams->hwRegister->configLut->iqDataCrossEn.append(k.iqDataCrossEn);
_scenParams->hwRegister->configLut->noiseRejectionEn.append(k.noiseRejectEn);
_scenParams->hwRegister->configLut->subtractFilterEn.append(k.subtractFilterEn);
}
_scenParams->hwRegister->mlaOffsetAddr = scenGenHw.hwRegister.mlaOffsetAddr;
_scenParams->hwRegister->noiseReject = scenGenHw.hwRegister.noiseRejectValue;
_scenParams->hwRegister->frameLoggerControl = scenGenHw.hwRegister.frameLoggerControl;
_scenParams->indexParams->endOfEnsemble = scenGenHw.indexParams.endOfEnsemble;
_scenParams->indexParams->endOfSubBatch = scenGenHw.indexParams.endOfSubBatch;
_scenParams->indexParams->endOfSubFrame = scenGenHw.indexParams.endOfSubFrame;
_scenParams->indexParams->isLastSubBatch = scenGenHw.indexParams.isLastSubBatch;
_scenParams->indexParams->startOfSubBatch = scenGenHw.indexParams.startOfSubBatch;
_scenParams->indexParams->firstLineInFrame = scenGenHw.indexParams.firstLineInFrame;
_scenParams->indexParams->shotPropertiesIndex = scenGenHw.indexParams.shotPropertiesIndex;
_scenParams->indexParams->pulsePropertiesIndex = scenGenHw.indexParams.pulsePropertiesIndex;
_scenParams->indexParams->receiverConfigurationIndex =
scenGenHw.indexParams.receiverConfigurationIndex;
_scenParams->txParams->maxDelayQ = scenGenHw.txParams.maxDelayQ;
_scenParams->txParams->txFocusXPos = scenGenHw.txParams.txFocusXPos;
_scenParams->txParams->txFocusYPos = scenGenHw.txParams.txFocusYPos;
_scenParams->txParams->txFocusZPos = scenGenHw.txParams.txFocusZPos;
_scenParams->txParams->pulseInterval = scenGenHw.pulseInterval;
_scenParams->txParams->txActiveElementNumber = scenGenHw.txParams.txActiveElementNumber;
_scenParams->txParams->txStartActiveElementNumber =
scenGenHw.txParams.txStartActiveElementNumber;
_scenParams->rxParams->phiCos = scenGenHw.rxParams.phiCos;
_scenParams->rxParams->phiSin = scenGenHw.rxParams.phiSin;
_scenParams->rxParams->thetaCos = scenGenHw.rxParams.thetaCos;
_scenParams->rxParams->thetaSin = scenGenHw.rxParams.thetaSin;
_scenParams->rxParams->r0Position = scenGenHw.rxParams.r0Position;
_scenParams->rxParams->interceptXPos = scenGenHw.rxParams.interceptXPos;
_scenParams->rxParams->interceptYPos = scenGenHw.rxParams.interceptYPos;
_scenParams->rxParams->interceptZPos = scenGenHw.rxParams.interceptZPos;
_scenParams->rxParams->rxR0MaxDelayQ = scenGenHw.rxParams.rxR0MaxDelayQ;
_scenParams->rxParams->rxR0MinDelayQ = scenGenHw.rxParams.rxR0MinDelayQ;
_scenParams->rxParams->txR0MinDelayQ = scenGenHw.rxParams.txR0MinDelayQ;
_scenParams->rxParams->rxFocusPointNumber = scenGenHw.rxParams.rxFocusPointNumber;
_scenParams->rxParams->rxActiveElementStep = scenGenHw.rxParams.rxActiveElementStep;
_scenParams->rxParams->rxR0ActiveElementNumber = scenGenHw.rxParams.rxR0ActiveElementNumber;
_scenParams->rxParams->interceptPointFiringTime = scenGenHw.rxParams.interceptPointFiringTime;
_scenParams->rxParams->rxR0CenterActiveElementNumber =
scenGenHw.rxParams.rxR0CenterActiveElementNumber;
if(scenGenHw.apodizationLut.size() != APODIZATIONLUT_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Apodization lut is out of range.");
}
_scenParams->apodizationLut = scenGenHw.apodizationLut;
if(scenGenHw.atgcLut.size() != ATGC_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Atgc lut is out of range.");
}
_scenParams->atgcLut = scenGenHw.atgcLut;
this->setScenario(_scenParams);
}
void TrxBoard::setScenario (ScenGenHardwareParam* _scenParams)
{
///////////////////////////////// BeamFormer setting ///////////////////////////////
QList<QList<quint32> > elementPosition;
QList<quint32> x;
QList<quint32> y;
QList<quint32> z;
//_signedQntzrVec.clear();
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->elementPosition->xPosition,
1,
18,
0,
0,
true,
true,
true);
QList<quint32> xPosQ = _unsignedQntzrVec.toList();
//QList<quint32> xPosQ = signedVector2unsignedList(_signedQntzrVec);
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->elementPosition->yPosition,
1,
18,
0,
0,
true,
true,
true);
QList<quint32> yPosQ = _unsignedQntzrVec.toList();
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->elementPosition->zPosition,
0,
17,
0,
0,
true,
true,
true);
QList<quint32> zPosQ = _unsignedQntzrVec.toList();
for(quint8 i = 0; i < 3; i++)
{
for(quint8 j = 0; j < SLAVE_ELEMENT_SEGMENT; j++)
{
x.append(xPosQ.at(_swapVec.at(j + i * SLAVE_ELEMENT_SEGMENT)));
y.append(yPosQ.at(_swapVec.at(j + i * SLAVE_ELEMENT_SEGMENT)));
z.append(zPosQ.at(_swapVec.at(j + i * SLAVE_ELEMENT_SEGMENT)));
}
elementPosition.append(x);
elementPosition.append(y);
elementPosition.append(z);
switch(i)
{
case 0:
this->_beamFormerSlave0->probeElementPosition(elementPosition);
break;
case 1:
this->_beamFormerSlave1->probeElementPosition(elementPosition);
break;
case 2:
this->_beamFormerSlave2->probeElementPosition(elementPosition);
break;
}
x.clear();
y.clear();
z.clear();
elementPosition.clear();
}
scenParamsFilling(set);
this->_beamFormerSlave0->rxBeamformerProperties(_scenParams->hwRegister->rxBeamFormerTypeNumber,
_scenParams->hwRegister->rxBeamformer);
this->_beamFormerSlave1->rxBeamformerProperties(_scenParams->hwRegister->rxBeamFormerTypeNumber,
_scenParams->hwRegister->rxBeamformer);
this->_beamFormerSlave2->rxBeamformerProperties(_scenParams->hwRegister->rxBeamFormerTypeNumber,
_scenParams->hwRegister->rxBeamformer);
scenParamsFilling(set);
this->_beamFormerSlave0->pulseProperties(_scenParams->hwRegister->pulseTypeNumber,
_scenParams->hwRegister->pulse);
this->_beamFormerSlave1->pulseProperties(_scenParams->hwRegister->pulseTypeNumber,
_scenParams->hwRegister->pulse);
this->_beamFormerSlave2->pulseProperties(_scenParams->hwRegister->pulseTypeNumber,
_scenParams->hwRegister->pulse);
scenParamsFilling(set);
this->_beamFormerSlave0->apodizationParameters(_scenParams->hwRegister->apodizationParams);
this->_beamFormerSlave1->apodizationParameters(_scenParams->hwRegister->apodizationParams);
this->_beamFormerSlave2->apodizationParameters(_scenParams->hwRegister->apodizationParams);
scenParamsFilling(set);
////this->_beamFormerSlave0->afeLut(_scenParams->hwRegister->afe);
////this->_beamFormerSlave1->afeLut(_scenParams->hwRegister->afe);
////this->_beamFormerSlave2->afeLut(_scenParams->hwRegister->afe);
////scenParamsFilling(set);
///////////////////////////////// DSP setting ///////////////////////////////
this->_dsp->receiverConfigurationLut(_scenParams->hwRegister->receiverConfigTypeNumber,
_scenParams->hwRegister->configLut);
//_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->freqLut, 0, 24, 0, 0, true);
//QList<quint32> freqLutQ = _unsignedQntzrVec.toList();
//this->_dsp->frequencyLut(freqLutQ);
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->freqStepLut,
1,
32,
16,
0,
true,
true,
true);
QList<quint32> freqStepLutQ = _unsignedQntzrVec.toList();
this->_dsp->freqStepLut(freqStepLutQ);
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->lpfWeightStepLut,
0,
16,
23,
0,
true);
QList<quint32> lpfWeightStepLutQ = _unsignedQntzrVec.toList();
this->_dsp->lpfWeightStepLut(lpfWeightStepLutQ);
_unsignedQntzrVec = Calculation::qntzr(_scenParams->hwRegister->startLpfWeightLut,
0,
17,
16,
0,
true);
QList<quint32> startLpfWeightLutQ = _unsignedQntzrVec.toList();
this->_dsp->startLpfWeightLut(startLpfWeightLutQ);
_unsignedQntzrVec =
Calculation::qntzr(_scenParams->hwRegister->dtgcLut, 0, 12, 8, 0, true, false);
QList<quint32> dtgcLutQ = _unsignedQntzrVec.toList();
this->_dsp->dtgcLut(dtgcLutQ);
//_unsignedQntzrVec =
//Calculation::qntzr(_scenParams->hwRegister->dualPathWeight, 0, 16, 15, 0, true, false);
//QList<quint32> dualPathQ = _unsignedQntzrVec.toList();
//this->_dsp->dualPathWeight(dualPathQ);
QList<quint32> temp;
QList<QList<quint32> > blendWeightQ;
//_signedQntzrVec.clear();
foreach(auto vec, _scenParams->hwRegister->blendWeight)
{
temp.clear();
_unsignedQntzrVec = Calculation::qntzr(vec, 0, 9, 8, 0, true, false, true);
temp = _unsignedQntzrVec.toList();
blendWeightQ.push_back(temp);
}
this->_dsp->blendWeight(blendWeightQ);
this->_dsp->mlaOffsetAddr(_scenParams->hwRegister->mlaOffsetAddr);
this->_dsp->startFreqLut(_scenParams->hwRegister->startFreqLut);
this->_dsp->endFreqLut(_scenParams->hwRegister->endFreqLut);
this->_dsp->freqPointLut(_scenParams->hwRegister->freqPoint);
this->_dsp->noiseReject(_scenParams->hwRegister->noiseReject);
this->_dsp->frameLoggerCtrl(_scenParams->hwRegister->frameLoggerControl);
this->_dsp->lpfLut(_scenParams->hwRegister->lpfLut);
this->_dsp->lpfScaleCoefficient(_scenParams->hwRegister->lpfScaleCoeff);
this->_dsp->dualPathWeight(_scenParams->hwRegister->dualPathWeight);
this->_beamFormerSlave0->apodizationLut(_scenParams->apodizationLut);
this->_beamFormerSlave1->apodizationLut(_scenParams->apodizationLut);
this->_beamFormerSlave2->apodizationLut(_scenParams->apodizationLut);
scenParamsFilling(set);
this->_dsp->atgcLut(_scenParams->atgcLut);
///////////////////////////////// Sram setting ///////////////////////////////
this->_sram->setSramIndex(_scenParams->totalTxShotNumber, _scenParams->indexParams);
this->_sram->setSramTx(_scenParams->focusTypeNumber, _scenParams->txParams);
this->_sram->setSramRx(_scenParams->rxBeamFormerNumber,
_scenParams->focusTypeNumber,
_scenParams->rxParams);
scenParamsFilling(set);
////////////////////////////// Scen Index setting ////////////////////////////
this->_scenPlayer->setStartIndex(_scenParams->scenarioStartIndex);
this->_scenPlayer->setEndIndex(_scenParams->scenarioEndIndex);
}
void TrxBoard::setLineFilterCoefficient(QVector<float>& lineFilterLut)
{
if(lineFilterLut.size() != LINE_FILTER_LUT_MAX)
{
throw HardwareException(SCN_ERROR, "Line filter lut is out of range.");
}
_unsignedQntzrVec = Calculation::qntzr(lineFilterLut, 0, 9, 8, 0, true, false);
QList<quint32> lineFilterLutQ = _unsignedQntzrVec.toList();
this->_dsp->lineFilterCoefficient(lineFilterLutQ);
}
void TrxBoard::setStbCoefficient(QVector<quint32>& stbLut)
{
if(stbLut.size() != STB_COEFFICIENT_LUT_MAX)
{
throw HardwareException(STB_ERROR, "Stb lut is out of range.");
}
QList<quint32> stbLutQ = stbLut.toList();
this->_dsp->stbCoefficient(stbLutQ);
}
void TrxBoard::setAtgcMode(eAtgcMode mode, quint16 value) const
{
this->_dsp->atgcMode(mode, value);
}
void TrxBoard::setDtgcLut(QVector<float>& dtgcLut)
{
if(dtgcLut.size() != DTGC_LUT_MAX)
{
throw HardwareException(DTGC_ERROR, "Dtgc lut is out of range.");
}
_unsignedQntzrVec = Calculation::qntzr(dtgcLut, 0, 12, 8, 0, true, false);
QList<quint32> dtgcLutQ = _unsignedQntzrVec.toList();
this->_dsp->dtgcLut(dtgcLutQ);
}
void TrxBoard::setFramesMetaData(const QByteArray& metaData)
{
preSubBatch = -1;
preBatch = 0;
qint32 metaLength = metaData.length();
if(!metaLength)
{
throw HardwareException(SCEN_SRAM_ERROR, "Meta data array is empty.");
}
if(static_cast<quint32>(metaLength) > META_DATA_LENGTH * 8)
{
throw HardwareException(SCEN_SRAM_ERROR, "Meta data byte array is out of range.");
}
QList<quint64> clear;
for(quint8 i = 0; i < META_DATA_LENGTH; i++)
{
clear.append(0);
}
this->_sram->setSramMetaData(clear);
QList<quint64> data;
QByteArray temp;
qint32 num(0);
while(metaLength)
{
for(quint8 j = 0; j < sizeof(quint64); j++)
{
if(metaLength)
{
temp.append(metaData[j + num]);
metaLength--;
}
else
{
temp.append(qint8(0));
}
}
data.push_back(byteArray2UintLittleEndian<quint64>(temp));
temp.clear();
num += sizeof(quint64);
}
this->_sram->setSramMetaData(data);
}
void TrxBoard::setMChangeParams(SramTx* tx, SramRx* rx) const
{
quint32 focusTypeNumber = 1;
QVector<quint8> rxBeamFormerNumber = {1};
this->_sram->setSramTx(focusTypeNumber, tx);
this->_sram->setSramRx(rxBeamFormerNumber,
focusTypeNumber,
rx);
}
void TrxBoard::setBiteDacData(const QByteArray& iData, const QByteArray& qData) const
{
this->_builtInTest->biteDacEnable(BITE_INTERVAL, false);
this->_builtInTest->biteDacMemoryWrite(iData, qData);
}
void TrxBoard::biteScenPlayerStart()
{
setDebuggerMode(pulserTr, true);
setAdgCfg(adgIQ);
setTxDacEnable(BITE_INTERVAL, true);
this->scenPlayerStart(true);
}
void TrxBoard::biteScenPlayerStop()
{
this->scenPlayerStop(true);
setTxDacEnable(BITE_INTERVAL, false);
setAdgCfg(adgGnd);
setDebuggerMode(pulserHz, true);
setDebuggerMode(pulserHz, false);
}
void TrxBoard::setScenarioCompare(const QString scenPath)
{
/******************* Create SRAM Binary File *******************/
QString createSramBinary = "/hardware/sramScenarioReadback.bin";
QString saveFile = scenPath + createSramBinary;
QFile sramFile(saveFile);
if(!sramFile.open(QIODevice::WriteOnly))
{
throw HardwareException(SRAM_CMP_ERROR, "Couldn't create the sram binary file due to the wrong path probably.");
}
quint32 num(0);
quint64 value(0);
while(num < SRAM_SIZE / 4)
{
value = _device.device.readLong(BAR_SRAM, static_cast<quint32>(num));
sramFile.write(uintLittleEndian2ByteArray<quint64>(value));
num += sizeof(quint64);
}
sramFile.flush();
sramFile.close();
#ifdef DEVELOP_UI
emit sramBinaryCreateFlag();
#endif
/******************* Compare Register CSV File *******************/
QString registerScenario = "/hardware/register.csv";
QString regReadParamsPath = scenPath + registerScenario;
QFile csvReadFile(regReadParamsPath);
if(!csvReadFile.open(QFile::ReadOnly))
{
throw HardwareException(SRAM_CMP_ERROR,
"Could not open the register's scenario params due to the wrong path probably.");
}
QString registerCompareScenario = "/hardware/registerCompare.csv";
QString regCompareParamsPath = scenPath + registerCompareScenario;
QFile csvWriteFile(regCompareParamsPath);
if(!csvWriteFile.open(QFile::WriteOnly))
{
throw HardwareException(SRAM_CMP_ERROR,
"Couldn't create the register compare file due to the wrong path probably.");
}
quint32 bar = 0;
qint64 readSize = 0;
QString line;
auto size = csvReadFile.size();
while(readSize < size)
{
line = csvReadFile.readLine();
auto sl = line.split(',');
auto address = sl[0].toUInt(Q_NULLPTR, 16);
auto baseValue = sl[1].toUInt(Q_NULLPTR, 16);
auto boardValue = _device.device.readWord(bar, address);
auto res = "NOK";
if(boardValue == baseValue)
{
res = "OK";
}
auto str = QStringLiteral("%1,%2,%3,%4")
.arg(address, 8, 16, QLatin1Char('0'))
.arg(baseValue, 8, 16, QLatin1Char('0'))
.arg(boardValue, 8, 16, QLatin1Char('0')).arg(res);
csvWriteFile.write(str.toStdString().c_str(), str.length());
csvWriteFile.write("\r\n", 2);
readSize += static_cast<qint64>(line.length());
}
csvReadFile.close();
csvWriteFile.flush();
csvWriteFile.close();
#ifdef DEVELOP_UI
emit registerCsvCompareFlag();
#endif
/******************* Compare & Verify SRAM Params *******************/
QString sramScenario = "/hardware/sramScenario.bin";
QString sramReadParamsPath = scenPath + sramScenario;
QFile sramReadFile(sramReadParamsPath);
if(!sramReadFile.open(QFile::ReadOnly))
{
throw HardwareException(SRAM_CMP_ERROR,
"Could not open the sram's scenario params due to the wrong path probably.");
}
qint64 sramScenarioLength = sramReadFile.size();
QByteArray fileByte;
fileByte = sramReadFile.readAll();
sramReadFile.close();
num = 0;
quint64 boardValue(0);
quint64 fileValue(0);
QByteArray temp;
while(num < sramScenarioLength)
{
boardValue = _device.device.readLong(BAR_SRAM, static_cast<quint32>(num));
for(quint8 j = 0; j < sizeof(quint64); j++)
{
temp.append(fileByte[j + num]);
}
fileValue = byteArray2UintLittleEndian<quint64>(temp);
if(boardValue != fileValue)
{
throw HardwareException(SRAM_CMP_ERROR, "The sram scenario file is different to the sram params of board.");
}
temp.clear();
num += sizeof(quint64);
}
#ifdef DEVELOP_UI
emit sramVerifyMessage("Successful comparision without any difference.");
#endif
}
QList<quint32> TrxBoard::getAfeReg(eSlaveSelect sel, quint32 afeRegAddr)
{
QList<quint32> afeRegValue;
quint32 offset(0);
afeRegValue.clear();
switch(sel)
{
case slave0:
this->_afeSlave0->setReadRegEnable(true);
this->delay(1);
for(quint8 i = 0; i < _afeModuleOffset.size(); i++)
{
offset = (_fpgaOffset.at(slave0) + _afeModuleOffset.at(i) + afeRegAddr) * 4;
afeRegValue.push_back(this->_device.device.readWord(BAR_REG, offset));
}
this->_afeSlave0->setReadRegEnable(false);
break;
case slave1:
this->_afeSlave1->setReadRegEnable(true);
this->delay(1);
for(quint8 i = 0; i < _afeModuleOffset.size(); i++)
{
offset = (_fpgaOffset.at(slave1) + _afeModuleOffset.at(i) + afeRegAddr) * 4;
afeRegValue.push_back(this->_device.device.readWord(BAR_REG, offset));
}
this->_afeSlave1->setReadRegEnable(false);
break;
case slave2:
this->_afeSlave2->setReadRegEnable(true);
this->delay(1);
for(quint8 i = 0; i < _afeModuleOffset.size(); i++)
{
offset = (_fpgaOffset.at(slave2) + _afeModuleOffset.at(i) + afeRegAddr) * 4;
afeRegValue.push_back(this->_device.device.readWord(BAR_REG, offset));
}
this->_afeSlave2->setReadRegEnable(false);
break;
}
return afeRegValue;
}
void TrxBoard::setAdgCfg(eBiteDacOutput adg) const
{
this->_builtInTest->biteAdgCfg(adg);
}
void TrxBoard::setTxDacEnable(quint8 biteInterval, bool cmd) const
{
this->_builtInTest->biteDacEnable(biteInterval, cmd);
}
void TrxBoard::powerAo(bool flag)
{
if(flag)
{
this->_bCtrlMngt->mpsDacsOn();
}
else
{
this->_bCtrlMngt->mpsDacsOff();
}
}
void TrxBoard::slaveFpgaProgram(const QString path)
{
scenParamsFilling(clear);
fpgaProgram(path, MOUNTED_SLAVE_FPGA);
#ifndef DEVELOP_UI
afeAdcsSync(MOUNTED_SLAVE_FPGA);
gtReadReset();
sonoHeartBeatsEnable();
#endif
}
void TrxBoard::setBeamFormerMode(eClkMode mode) const
{
this->_clkDistributer->clockMode(CLOCK_DIVISION, mode);
}
void TrxBoard::afesHvDacsOn() const
{
setAfesPwr(afePwrdnDisable);
// setAfesFastPwr(afePwrdnDisable);
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOn();
#endif
}
void TrxBoard::afesHvDacsOff() const
{
setAfesPwr(afePwrdnEnable);
// setAfesFastPwr(afePwrdnEnable);
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOff();
#endif
}
#ifndef DEVELOP_UI
void TrxBoard::scenPlayerStart(int count, bool afeHvPwrOn)
{
if(_allow)
{
_run = false;
this->_beamFormerSlave0->regValid(true);
this->_beamFormerSlave1->regValid(true);
this->_beamFormerSlave2->regValid(true);
this->_misc->setGtSendMode(bfMode);
this->_misc->setSyncMode(bfSyncMode);
this->_emul->setEmulatorDis();
this->_device.resetCounter();
this->_device.startDma();
if(afeHvPwrOn)
{
this->_afeSlave0->setAfeGblPwr(afePwrdnDisable);
this->_afeSlave1->setAfeGblPwr(afePwrdnDisable);
this->_afeSlave2->setAfeGblPwr(afePwrdnDisable);
//quint32 afeFastPdn = 0x43C36C;
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0, static_cast<quint32>(0));
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0x400000,
//static_cast<quint32>(0));
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0x800000,
//static_cast<quint32>(0));
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOn();
#endif
this->delay(170);
}
this->_scenPlayer->control.setCommand(true);
_sonoLiveTimer->start(5000);
_sonoHeartBeats = true;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
packetEngine.init();
_run = true;
QtConcurrent::run(this, &TrxBoard::readLimitedData, count);
}
else
{
throw HardwareException(SCEN_START_ERROR, "Total scenario luts and sram parameters have not written compeletely.");
}
}
void TrxBoard::readLimitedData(int count)
{
int generatedFrame = 0;
preBatch = 0;
_swCounter = _device.getCounter();
do
{
auto cnt = _device.getCounter();
if(cnt == 0)
{
_hwCounter = 0;
std::this_thread::sleep_for(std::chrono::milliseconds(3));
continue;
}
else if(cnt != _hwCounter)
{
_hwCounter++;
if(_hwCounter > HW_BUFFER_NUM)
{
_hwCounter = 1;
}
_device.copy(_hwCounter - 1, _swCounter);
auto framePacket =
QByteArray::fromRawData(_device.getBufferPtr(_swCounter), BUFFER_SIZE);
auto batch = ((static_cast<quint16>(framePacket[128])) & 0x00FF) |
(((static_cast<quint16>(framePacket[129])) << 8) & 0xFF00);
auto subBbatch = ((static_cast<quint16>(framePacket[130])) & 0x00FF);
if((batch == preBatch && subBbatch - preSubBatch != 1) ||
(preSubBatch == -1 && (batch != 0 || subBbatch != 0)) ||
(batch - preBatch > 1) ||
(batch - preBatch == 1 && subBbatch != 0))
{
//throw;
}
if(batch != preBatch)
{
generatedFrame++;
}
qDebug() << "*******************batch " << batch << "|geteratedFrame " <<
generatedFrame;
preBatch = batch;
preSubBatch = subBbatch;
packetEngine.newData(framePacket);
_swCounter++;
if(_swCounter >= SW_BUFFER_NUM)
{
_swCounter = 0;
}
}
}while (generatedFrame < count);
scenStopAfterReadLimited();
}
void TrxBoard::scenStopAfterReadLimited()
{
_run = false;
this->_device.stopDma();
//uncrustify off
while(_device.isDmaBusy());
//uncrustify on
_sonoLiveTimer->stop();
_sonoHeartBeats = false;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
this->_scenPlayer->control.setCommand(false);
this->_afeSlave0->setAfeGblPwr(afePwrdnEnable);
this->_afeSlave1->setAfeGblPwr(afePwrdnEnable);
this->_afeSlave2->setAfeGblPwr(afePwrdnEnable);
//quint32 afeFastPdn = 0x43C36C;
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0, static_cast<quint32>(1));
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0x400000, static_cast<quint32>(1));
//this->_device.device.writeWord(BAR_REG, afeFastPdn + 0x800000, static_cast<quint32>(1));
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOff();
#endif
QThread::msleep(140);
}
#endif
/* set afeHvPwrOn true when unfreeze happen */
void TrxBoard::scenPlayerStart(bool unfreezeWithoutScenChanging)
{
if(isScenarioStart())
{
return;
}
if(_allow)
{
_run = false;
this->_beamFormerSlave0->regValid(true);
this->_beamFormerSlave1->regValid(true);
this->_beamFormerSlave2->regValid(true);
this->_misc->setGtSendMode(bfMode);
this->_misc->setSyncMode(bfSyncMode);
this->_emul->setEmulatorDis();
this->_device.resetCounter();
this->_device.startDma();
if(unfreezeWithoutScenChanging)
{
afesHvDacsOn();
this->delay(170);
}
this->_scenPlayer->control.setCommand(true);
#ifndef DEVELOP_UI
packetEngine.init();
#endif
_sonoLiveTimer->start(5000);
_sonoHeartBeats = true;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
_run = true;
QtConcurrent::run(this, &TrxBoard::readData);
}
else
{
throw HardwareException(SCEN_START_ERROR, "Total scenario luts and sram parameters have not written compeletely.");
}
}
/* set afeHvPwrOff true when freeze happen */
void TrxBoard::scenPlayerStop(bool freezeWithoutScenChanging)
{
if(!isScenarioStart())
{
return;
}
_run = false;
this->_device.stopDma();
this->_scenPlayer->control.setCommand(false);
//uncrustify off
// while(_device.isDmaBusy());
//uncrustify on
_sonoLiveTimer->stop();
_sonoHeartBeats = false;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
if(freezeWithoutScenChanging)
{
afesHvDacsOff();
this->delay(140);
}
}
bool TrxBoard::isScenarioStart() const
{
return this->_scenPlayer->control.getCommand();
}
//void TrxBoard::scenPlayerPause(bool pause) const
//{
//this->_scenPlayer->control.pause(pause);
//}
void TrxBoard::emulatorInit(EmulatorProperties* config) const
{
this->_emul->setTransferMode(config->emulOption, config->emulMode, config->transferLength);
this->_emul->setRamOffsetAddress(config->ramBufAddress);
this->_emul->setTransferRate(config->transferRate);
}
void TrxBoard::fillRam(QString path)
{
if(this->_scenPlayer->control.getCommand())
{
scenPlayerStop(true);
}
emulatorStop();
QFile emulFile(path);
QByteArray sramData;
QByteArray temp;
qint32 num(0);
sramData.clear();
temp.clear();
if(emulFile.fileName().isEmpty())
{
throw HardwareException(EMU_DMA_ERROR, "No file has selected.");
}
if(!emulFile.open(QIODevice::ReadOnly))
{
throw HardwareException(EMU_DMA_ERROR, "Couldn't open frame file to emulator test.");
}
sramData = emulFile.readAll();
emulFile.close();
while(num < sramData.size())
{
for(quint8 j = 0; j < sizeof(quint64); j++)
{
temp.append(sramData[j + num]);
}
this->_device.device.writeLong(BAR_SRAM,
static_cast<quint32>(num),
byteArray2UintLittleEndian<quint64>(temp));
temp.clear();
num += sizeof(quint64);
}
}
void TrxBoard::emulatorStart()
{
_run = false;
this->_scenPlayer->control.setCommand(false);
this->_emul->setEmulatorEn();
this->_device.resetCounter();
this->_device.startDma();
_sonoLiveTimer->start(5000);
_sonoHeartBeats = true;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
_run = true;
QtConcurrent::run(this, &TrxBoard::readData);
}
void TrxBoard::emulatorStop()
{
_sonoLiveTimer->stop();
_sonoHeartBeats = false;
this->_scenPlayer->control.setHeartBeats(_sonoHeartBeats);
this->setAfesHeartBeat(_sonoHeartBeats);
_run = false;
this->_device.stopDma();
this->_emul->setEmulatorDis();
}
quint32 TrxBoard::deviceId() const
{
auto pid = this->_bCtrlMngt->getPid();
return pid;
}
quint32 TrxBoard::vendorId() const
{
auto vid = this->_bCtrlMngt->getVid();
return vid;
}
void TrxBoard::systemCompare(QList<quint32> &currentSystem, QList<QList<quint32>> &systemDataset) const
{
foreach(auto &lut, systemDataset)
{
if(lut == currentSystem)
{
return;
}
}
throw HardwareException(TRX_READ_FAILED, "The system parameters are not compatible.");
}
void TrxBoard::checkSystemCompatibility(QList<systemE2proms> &systemLut)
{
EepromStatus trxE2prom, prbCtrlE2prom, mpsE2prom;
this->trxState(trxE2prom);
this->prbCtrlState(prbCtrlE2prom);
this->mpsState(mpsE2prom);
systemE2proms currentSystemRoms;
currentSystemRoms.trx = trxE2prom;
currentSystemRoms.prbCtrl = prbCtrlE2prom;
currentSystemRoms.mps = mpsE2prom;
// getFpgasCodeVersion(&currentSystemRoms.fpgaCodeVersion);
QList<quint32> currentSystem = systemStructure2List(currentSystemRoms);
QList<QList<quint32>> systemDataset;
foreach(auto lut, systemLut)
{
systemDataset.append(systemStructure2List(lut));
}
systemCompare(currentSystem, systemDataset);
}
quint8 TrxBoard::crcGenerator(QByteArray inputByteArray) const
{
quint8 arrayLength = static_cast<quint8>(inputByteArray.length());
quint8 *input = new quint8[arrayLength];
memcpy(input, inputByteArray, arrayLength);
quint8 crcInitialValue(0x00);
int i;
while(arrayLength--)
{
crcInitialValue = crcInitialValue ^ *input++; // Apply Byte
for(i=0; i<8; i++) // Eight rounds of 1-bit
{
if (crcInitialValue & 0x80)
crcInitialValue = static_cast<quint8>((crcInitialValue << 1) ^ CRC_POLYNOMIAL);
else
crcInitialValue = static_cast<quint8>(crcInitialValue << 1); // Left Shifting
}
}
return(crcInitialValue);
}
void TrxBoard::crcCheck(const QByteArray array, quint8 crcRom) const
{
quint8 crcGen = crcGenerator(array);
if(crcGen != crcRom)
{
throw HardwareException(PROBE_CRC_ERROR, "CRC check error happend.");
}
}
void TrxBoard::trxCrcCheck(const QByteArray array, quint32 offset) const
{
quint8 crcRom = static_cast<quint8>((this->_bCtrlMngt->trxEepromRead(offset, CRC8_BYTE_NUMBER)).at(0));
crcCheck(array, crcRom);
}
void TrxBoard::prbCtrlCrcCheck(const QByteArray array, quint32 offset) const
{
quint8 crcRom = static_cast<quint8>((this->_bCtrlMngt->prbCtrlEepromRead(offset, CRC8_BYTE_NUMBER)).at(0));
crcCheck(array, crcRom);
}
void TrxBoard::mpsCrcCheck(const QByteArray array, quint32 offset) const
{
quint8 crcRom = static_cast<quint8>((this->_bCtrlMngt->mpsEepromRead(offset, CRC8_BYTE_NUMBER)).at(0));
crcCheck(array, crcRom);
}
QByteArray TrxBoard::trxRomHeader() const
{
QByteArray header = (this->_bCtrlMngt->trxEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER));
if(headerArray != header)
{
throw HardwareException(TRX_READ_FAILED, "The header checksum of the TRX e2prom corrupted.");
}
return header;
}
QByteArray TrxBoard::trxRomId() const
{
QByteArray id = (this->_bCtrlMngt->trxEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER));
trxCrcCheck(id, EEPROM_ID_CRC);
return id;
}
QByteArray TrxBoard::trxRomPid() const
{
QByteArray pid = (this->_bCtrlMngt->trxEepromRead(EEPROM_PID_BEGIN, EEPROM_PID_NUMBER));
trxCrcCheck(pid, EEPROM_PID_CRC);
return pid;
}
QByteArray TrxBoard::trxRomPcbVersion() const
{
QByteArray pcb = (this->_bCtrlMngt->trxEepromRead(EEPROM_PCB_VERSION_BEGIN, EEPROM_PCB_VERSION_NUMBER));
trxCrcCheck(pcb, EEPROM_PCB_VERSION_CRC);
return pcb;
}
QByteArray TrxBoard::trxRomSerialNo() const
{
QByteArray serial = (this->_bCtrlMngt->trxEepromRead(EEPROM_BOARD_SERIAL_NO_BEGIN, EEPROM_BOARD_SERIAL_NO_NUMBER));
trxCrcCheck(serial, EEPROM_BOARD_SERIAL_NO_CRC);
return serial;
}
QByteArray TrxBoard::trxRomFirstMbedCode() const
{
QByteArray mbed1 = (this->_bCtrlMngt->trxEepromRead(EEPROM_FIRST_MBED_CODE_VERSION_BEGIN, EEPROM_FIRST_MBED_CODE_VERSION_NUMBER));
trxCrcCheck(mbed1, EEPROM_FIRST_MBED_CODE_VERSION_CRC);
return mbed1;
}
QByteArray TrxBoard::trxRomSecondMbedCode() const
{
QByteArray mbed2 = (this->_bCtrlMngt->trxEepromRead(EEPROM_SECOND_MBED_CODE_VERSION_BEGIN, EEPROM_SECOND_MBED_CODE_VERSION_NUMBER));
trxCrcCheck(mbed2, EEPROM_SECOND_MBED_CODE_VERSION_CRC);
return mbed2;
}
void TrxBoard::trxState(EepromStatus& romStatus) const
{
QByteArray header;
QByteArray id;
QByteArray pid;
QByteArray pcbVersion;
QByteArray serialNo;
QByteArray firstMbedCode;
QByteArray secondMbedCode;
romStatus.ConnectionMode = connected;
romStatus.errorCode = EEPROM_NO_ERROR;
header = trxRomHeader();
romStatus.header = byteArray2UintBigEndian<quint32>(header);
id = trxRomId();
romStatus.id = byteArray2UintBigEndian<quint16>(id);
pid = trxRomPid();
romStatus.pid = byteArray2UintBigEndian<quint16>(pid);
pcbVersion = trxRomPcbVersion();
romStatus.pcbVersion = byteArray2UintBigEndian<quint16>(pcbVersion);
serialNo = trxRomSerialNo();
romStatus.boardSerialNumber = byteArray2UintBigEndian<quint32>(serialNo);
firstMbedCode = trxRomFirstMbedCode();
romStatus.firstMbedCodeVersion = byteArray2UintBigEndian<quint32>(firstMbedCode);
secondMbedCode = trxRomSecondMbedCode();
romStatus.secondMbedCodeVersion = byteArray2UintBigEndian<quint32>(secondMbedCode);
}
QByteArray TrxBoard::mpsRomHeader() const
{
QByteArray header = (this->_bCtrlMngt->mpsEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER));
if(headerArray != header)
{
throw HardwareException(MPS_READ_FAILED, "The header checksum of the MPS e2prom corrupted.");
}
return header;
}
QByteArray TrxBoard::mpsRomId() const
{
QByteArray id = (this->_bCtrlMngt->mpsEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER));
mpsCrcCheck(id, EEPROM_ID_CRC);
return id;
}
QByteArray TrxBoard::mpsRomPid() const
{
QByteArray pid = (this->_bCtrlMngt->mpsEepromRead(EEPROM_PID_BEGIN, EEPROM_PID_NUMBER));
mpsCrcCheck(pid, EEPROM_PID_CRC);
return pid;
}
QByteArray TrxBoard::mpsRomPcbVersion() const
{
QByteArray pcb = (this->_bCtrlMngt->mpsEepromRead(EEPROM_PCB_VERSION_BEGIN, EEPROM_PCB_VERSION_NUMBER));
mpsCrcCheck(pcb, EEPROM_PCB_VERSION_CRC);
return pcb;
}
QByteArray TrxBoard::mpsRomSerialNo() const
{
QByteArray serial = (this->_bCtrlMngt->mpsEepromRead(EEPROM_BOARD_SERIAL_NO_BEGIN, EEPROM_BOARD_SERIAL_NO_NUMBER));
mpsCrcCheck(serial, EEPROM_BOARD_SERIAL_NO_CRC);
return serial;
}
QByteArray TrxBoard::mpsRomFirstMbedCode() const
{
QByteArray mbed1 = (this->_bCtrlMngt->mpsEepromRead(EEPROM_FIRST_MBED_CODE_VERSION_BEGIN, EEPROM_FIRST_MBED_CODE_VERSION_NUMBER));
mpsCrcCheck(mbed1, EEPROM_FIRST_MBED_CODE_VERSION_CRC);
return mbed1;
}
QByteArray TrxBoard::mpsRomSecondMbedCode() const
{
QByteArray mbed2 = (this->_bCtrlMngt->mpsEepromRead(EEPROM_SECOND_MBED_CODE_VERSION_BEGIN, EEPROM_SECOND_MBED_CODE_VERSION_NUMBER));
mpsCrcCheck(mbed2, EEPROM_SECOND_MBED_CODE_VERSION_CRC);
return mbed2;
}
void TrxBoard::mpsState(EepromStatus& romStatus) const
{
QByteArray header;
QByteArray id;
QByteArray pid;
QByteArray pcbVersion;
QByteArray serialNo;
QByteArray firstMbedCode;
QByteArray secondMbedCode;
romStatus.ConnectionMode = connected;
romStatus.errorCode = EEPROM_NO_ERROR;
header = mpsRomHeader();
romStatus.header = byteArray2UintBigEndian<quint32>(header);
id = mpsRomId();
romStatus.id = byteArray2UintBigEndian<quint16>(id);
pid = mpsRomPid();
romStatus.pid = byteArray2UintBigEndian<quint16>(pid);
pcbVersion = mpsRomPcbVersion();
romStatus.pcbVersion = byteArray2UintBigEndian<quint16>(pcbVersion);
serialNo = mpsRomSerialNo();
romStatus.boardSerialNumber = byteArray2UintBigEndian<quint32>(serialNo);
firstMbedCode = mpsRomFirstMbedCode();
romStatus.firstMbedCodeVersion = byteArray2UintBigEndian<quint32>(firstMbedCode);
secondMbedCode = mpsRomSecondMbedCode();
romStatus.secondMbedCodeVersion = byteArray2UintBigEndian<quint32>(secondMbedCode);
}
QByteArray TrxBoard::prbCtrlRomHeader() const
{
QByteArray header = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_HEADER_BEGIN, EEPROM_HEADER_NUMBER));
if(headerArray != header)
{
throw HardwareException(RELAY_READ_FAILED, "The header checksum of the relay e2prom corrupted.");
}
return header;
}
QByteArray TrxBoard::prbCtrlRomId() const
{
QByteArray id = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER));
prbCtrlCrcCheck(id, EEPROM_ID_CRC);
return id;
}
QByteArray TrxBoard::prbCtrlRomPid() const
{
QByteArray pid = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_PID_BEGIN, EEPROM_PID_NUMBER));
prbCtrlCrcCheck(pid, EEPROM_PID_CRC);
return pid;
}
QByteArray TrxBoard::prbCtrlRomPcbVersion() const
{
QByteArray pcb = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_PCB_VERSION_BEGIN, EEPROM_PCB_VERSION_NUMBER));
prbCtrlCrcCheck(pcb, EEPROM_PCB_VERSION_CRC);
return pcb;
}
QByteArray TrxBoard::prbCtrlRomSerialNo() const
{
QByteArray serial = (this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_BOARD_SERIAL_NO_BEGIN, EEPROM_BOARD_SERIAL_NO_NUMBER));
prbCtrlCrcCheck(serial, EEPROM_BOARD_SERIAL_NO_CRC);
return serial;
}
void TrxBoard::prbCtrlState(EepromStatus& romStatus) const
{
QByteArray header;
QByteArray id;
QByteArray pid;
QByteArray pcbVersion;
QByteArray serialNo;
QByteArray firstMbedCode;
QByteArray secondMbedCode;
romStatus.ConnectionMode = connected;
romStatus.errorCode = EEPROM_NO_ERROR;
header = prbCtrlRomHeader();
romStatus.header = byteArray2UintBigEndian<quint32>(header);
id = prbCtrlRomId();
romStatus.id = byteArray2UintBigEndian<quint16>(id);
pid = prbCtrlRomPid();
romStatus.pid = byteArray2UintBigEndian<quint16>(pid);
pcbVersion = prbCtrlRomPcbVersion();
romStatus.pcbVersion = byteArray2UintBigEndian<quint16>(pcbVersion);
serialNo = prbCtrlRomSerialNo();
romStatus.boardSerialNumber = byteArray2UintBigEndian<quint32>(serialNo);
}
void TrxBoard::selectedPrbState(EepromStatus& romStatus, eSelectProbe prbSel) const
{
QVector<bool> vec;
QByteArray id;
QByteArray crcChk;
vec = this->_bCtrlMngt->getConnectedPrb();
if(prbSel == prbA && !vec.at(0))
{
throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected.");
}
if(prbSel == prbB && !vec.at(1))
{
throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected.");
}
if(prbSel == prbC && !vec.at(2))
{
throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected.");
}
if(prbSel == prbD && !vec.at(3))
{
throw HardwareException(PROBE_SEL_FAILED, "This probe has disconnected.");
}
romStatus.ConnectionMode = connected;
id = this->_bCtrlMngt->prbEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER, prbSel - 1);
romStatus.id = byteArray2UintBigEndian<quint16>(id);
crcChk = this->_bCtrlMngt->prbEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER, prbSel - 1);
if(crcChk == _eepromCrc)
{
romStatus.errorCode = EEPROM_NO_ERROR;
}
else
{
romStatus.errorCode = EEPROM_CRC_ERROR;
}
}
void TrxBoard::prbState(PrbCase* prb) const
{
QVector<bool> vec;
QByteArray id;
QByteArray crcChk;
vec = this->_bCtrlMngt->getConnectedPrb();
for(quint8 i(0); i < vec.size(); i++)
{
switch(i)
{
case 0:
if(vec.at(i))
{
prb->prbA.ConnectionMode = connected;
id = this->_bCtrlMngt->prbEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER, i);
prb->prbA.id = byteArray2UintBigEndian<quint16>(id);
crcChk =
this->_bCtrlMngt->prbEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER, i);
if(crcChk == _eepromCrc)
{
prb->prbA.errorCode = EEPROM_NO_ERROR;
}
else
{
prb->prbA.errorCode = EEPROM_CRC_ERROR;
}
}
else
{
prb->prbA.ConnectionMode = disconnected;
prb->prbA.id = 0;
prb->prbA.errorCode = EEPROM_NO_ERROR;
}
break;
case 1:
if(vec.at(i))
{
prb->prbB.ConnectionMode = connected;
id = this->_bCtrlMngt->prbEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER, i);
prb->prbB.id = byteArray2UintBigEndian<quint16>(id);
crcChk =
this->_bCtrlMngt->prbEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER, i);
if(crcChk == _eepromCrc)
{
prb->prbB.errorCode = EEPROM_NO_ERROR;
}
else
{
prb->prbB.errorCode = EEPROM_CRC_ERROR;
}
}
else
{
prb->prbB.ConnectionMode = disconnected;
prb->prbB.id = 0;
prb->prbB.errorCode = EEPROM_NO_ERROR;
}
break;
case 2:
if(vec.at(i))
{
prb->prbC.ConnectionMode = connected;
id = this->_bCtrlMngt->prbEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER, i);
prb->prbC.id = byteArray2UintBigEndian<quint16>(id);
crcChk =
this->_bCtrlMngt->prbEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER, i);
if(crcChk == _eepromCrc)
{
prb->prbC.errorCode = EEPROM_NO_ERROR;
}
else
{
prb->prbC.errorCode = EEPROM_CRC_ERROR;
}
}
else
{
prb->prbC.ConnectionMode = disconnected;
prb->prbC.id = 0;
prb->prbC.errorCode = EEPROM_NO_ERROR;
}
break;
case 3:
if(vec.at(i))
{
prb->prbD.ConnectionMode = connected;
id = this->_bCtrlMngt->prbEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER, i);
prb->prbD.id = byteArray2UintBigEndian<quint16>(id);
crcChk =
this->_bCtrlMngt->prbEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER, i);
if(crcChk == _eepromCrc)
{
prb->prbD.errorCode = EEPROM_NO_ERROR;
}
else
{
prb->prbD.errorCode = EEPROM_CRC_ERROR;
}
}
else
{
prb->prbD.ConnectionMode = disconnected;
prb->prbD.id = 0;
prb->prbD.errorCode = EEPROM_NO_ERROR;
}
break;
}
id.clear();
crcChk.clear();
}
}
//QString TrxBoard::trxInfo() const
//{
// FpgaCodeVersion version;
// getFpgasCodeVersion(&version);
// QString info = QString(this->_bCtrlMngt->trxEepromRead(EEPROM_INFO_BEGIN, EEPROM_INFO_NUMBER));
// return (info + "(FPM-V " + QString::number(version.masterCode, 10) +
// ", FPS-V " + QString::number(version.slave0Code, 10) + ")");
//}
//QString TrxBoard::mpsInfo() const
//{
// return QString(this->_bCtrlMngt->mpsEepromRead(EEPROM_INFO_BEGIN, EEPROM_INFO_NUMBER));
//}
//QString TrxBoard::prbCtrlInfo() const
//{
// return QString(this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_INFO_BEGIN, EEPROM_INFO_NUMBER));
//}
QByteArray TrxBoard::selectedPrbImpulseResponse(quint8 prbSel) const
{
return this->_bCtrlMngt->prbEepromRead(EEPROM_IMPULSE_RESPONSE_BEGIN,
EEPROM_IMPULSE_RESPONSE_NUMBER,
prbSel);
}
void TrxBoard::prbImpulseResponse(ConnectedPrbInfo* prbInfo) const
{
QByteArray info;
QVector<bool> vec;
info.clear();
vec.clear();
vec = this->_bCtrlMngt->getConnectedPrb();
for(quint8 i = 0; i < vec.size(); i++)
{
if(vec.at(i))
{
info = this->_bCtrlMngt->prbEepromRead(EEPROM_IMPULSE_RESPONSE_BEGIN,
EEPROM_IMPULSE_RESPONSE_NUMBER,
i);
}
else
{
info.append(nullptr);
}
switch(i)
{
case 0:
prbInfo->prbA = info;
break;
case 1:
prbInfo->prbB = info;
break;
case 2:
prbInfo->prbC = info;
break;
case 3:
prbInfo->prbD = info;
break;
}
info.clear();
}
}
void TrxBoard::supervisorRbValue(SupervisorRbValue* sValue) const
{
this->_bCtrlMngt->getSupervisorValue(sValue);
}
void TrxBoard::mpsFaultStatus(MpsFaultStatus* faultStatus) const
{
this->_bCtrlMngt->getMpsFault(faultStatus);
}
void TrxBoard::mpsPwrOn() const
{
this->_bCtrlMngt->mpsInit();
}
void TrxBoard::mpsPwrOff() const
{
this->_bCtrlMngt->mpsDeInit();
}
void TrxBoard::mpsReset() const
{
this->_bCtrlMngt->setMpsReset();
}
void TrxBoard::mpsSetAo(float voltA, float voltB) const
{
this->_bCtrlMngt->mpsHvSet(voltA, voltB);
}
void TrxBoard::selectProbe(eSelectProbe prbSel)
{
if(this->_scenPlayer->control.getCommand())
{
scenPlayerStop(true);
}
this->_bCtrlMngt->setProbeSelect(prbSel);
}
void TrxBoard::getHealthStatus(HealthStatus* healStat) const
{
this->_bCtrlMngt->getFanRpm(_tachoRpm);
this->_bCtrlMngt->getTrxVoltagesPg(_pg);
this->_bCtrlMngt->getFpgaTemp(_coreTemp);
this->_bCtrlMngt->getTrxBoardVoltages(_adc, _pg);
this->_bCtrlMngt->getFpgaVccInt(_coreVolt->vccInt);
this->_bCtrlMngt->getFpgaVccAux(_coreVolt->vccAux);
this->_bCtrlMngt->getFpgaVccBram(_coreVolt->vccBram);
healStat->voltsPg = _pg;
healStat->adcMon = _adc;
healStat->fanRpm = _tachoRpm;
healStat->fpgaCoreVoltages = _coreVolt;
healStat->fpgaCoreTemperature = _coreTemp;
healStat->systemTemperature = this->_bCtrlMngt->getTrxTempSensor();
//healStat->mpsTemperature = this->_bCtrlMngt->getMpsTempSensor();
}
void TrxBoard::setTrxFanRpm(const eFanPwm& fan, const quint8& dutyCyclePercent) const
{
if(dutyCyclePercent > 100)
{
throw HardwareException(FAN_FAULT_DETECTED, "Out of range for fan duty cycle.");
}
this->_bCtrlMngt->setFanPwm(fan, dutyCyclePercent);
}
void TrxBoard::setRegulatorSyncClk(const eRegSync& regType, const regulatorSync& regSyncParams) const
{
if(regSyncParams.halfPeriod > 8192)
{
throw HardwareException(TRX_READ_FAILED, "Out of range for PLL sync clk.");
}
this->_bCtrlMngt->setPllRefClk(regType, regSyncParams);
}
void TrxBoard::mcsProgram(QString path)
{
QFile mcsFile(path);
if(mcsFile.fileName().isEmpty())
{
throw HardwareException(TRX_READ_FAILED, "No file has selected.");
}
if(!mcsFile.open(QIODevice::ReadOnly))
{
throw HardwareException(TRX_READ_FAILED, "Couldn't open BPI bin file programming.");
}
QByteArray mcsFileData = mcsFile.readAll();
mcsFile.close();
this->_bpiFlash->writeMcs(mcsFileData);
}
void TrxBoard::mcsVerify(QString path) const
{
mcsRead(path);
}
void TrxBoard::spiFlashProgram(QString path)
{
QFile binFile(path);
if(binFile.fileName().isEmpty())
{
throw HardwareException(TRX_READ_FAILED, "No file has selected.");
}
if(!binFile.open(QIODevice::ReadOnly))
{
throw HardwareException(TRX_READ_FAILED, "Couldn't open SPI flash bin file programming.");
}
bin = binFile.readAll();
binFile.close();
this->_spiFlash->writeBin(bin, update);
}
void TrxBoard::spiFlashRead(QString path)
{
for(quint8 i(0); i < 2; i++)
{
QByteArray binArray;
QFile binFile(path + "/SPI_bin_rdback.bin");
if(path.isEmpty())
{
throw HardwareException(TRX_READ_FAILED, "No file has selected.");
}
if(!binFile.open(QIODevice::WriteOnly))
{
throw HardwareException(TRX_READ_FAILED, "Couldn't open SPI bin file programming.");
}
binArray = this->_spiFlash->readBin();
binFile.write(binArray);
binFile.flush();
binFile.close();
}
}
void TrxBoard::spiFlashVerify()
{
QList<quint32> data;
quint32 baseAddr = 0x4000000;
bool firstFifo(true);
for(qint32 i(0); i < bin.size() / 16; i++)
{
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x68, 0x3);
for(quint8 i(0); i < 15; i++)
{
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x68, 0x0);
}
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x70, 0xFFFFFFFE);
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x60, 0x86);
delay(1);
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x60, 0x186);
delay(1);
for(quint8 j(0); j < 16; j++)
{
data.push_back(this->_device.device.readWord(BAR_SRAM, baseAddr + 0x6C));
if(firstFifo)
{
if(j >= 4)
{
if(data[j] != static_cast<quint8>(bin[j - 4]))
{
qDebug() << "Error at index: " << (j - 4) << "---" << "rdData=" <<
QString::number(data[j], 16) <<
"***" << "binFile=" <<
QString::number(static_cast<quint8>(bin[j - 4]), 16);
}
}
}
else
{
if(data[j] != static_cast<quint8>(bin[(j - 4) + 16 * i]))
{
qDebug() << "Error at index: " << (j - 4) + 16 * i << "rdData=" <<
QString::number(
data[j],
16) <<
"***" <<
"binFile=" <<
QString::number(static_cast<quint8>(bin[(j - 4) + 16 * i]), 16);
}
}
}
firstFifo = false;
data.clear();
}
for(quint8 i(0); i < bin.size() % 16; i++)
{
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x68, 0x0);
}
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x70, 0xFFFFFFFE);
delay(1);
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x60, 0x86);
delay(1);
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x60, 0x186);
delay(1);
for(quint8 i(0); i < bin.size() % 16; i++)
{
data.push_back(this->_device.device.readWord(BAR_SRAM, baseAddr + 0x6C));
if(data[i] != static_cast<quint8>(bin[(i - 4) + 16 * (bin.size() / 16)]))
{
qDebug() << "Error at index: " << (i - 4) + 16 * (bin.size() / 16) << "rdData=" <<
QString::number(
data[i],
16) <<
"***" <<
"binFile=" <<
QString::number(static_cast<quint8>(bin[(i - 4) + 16 * (bin.size() / 16)]), 16);
}
delay(1);
}
this->_device.device.writeWord(BAR_SRAM, baseAddr + 0x70, 0x1);
qDebug() << "Verification End.";
}
void TrxBoard::getTrxStatus(StatusVec* status) const
{
this->_misc->getStatusVector(status);
}
void TrxBoard::getFpgasCodeVersion(FpgaCodeVersion* version) const
{
this->_misc->getFpgaVersion(version);
}
void TrxBoard::sramParityClear()
{
quint64 val;
val = this->_device.device.readLong(BAR_SRAM, 0);
this->_device.device.writeLong(BAR_SRAM, 0, val);
}
quint32 TrxBoard::getFrameLostCounter() const
{
return (this->_misc->getFrameLostCount());
}
void TrxBoard::elementActiveEnable(eActiveElements& slaveElements, quint64& elements) const
{
QList<quint32> littleEndianList;
quint32 highElements = elements >> 32;
quint32 lowElements = elements & 0xFFFFFFFF;
littleEndianList.push_back(lowElements);
littleEndianList.push_back(highElements);
switch(slaveElements)
{
case slave0Elements:
this->_beamFormerSlave0->elementActiveEn(littleEndianList);
break;
case slave1Elements:
this->_beamFormerSlave1->elementActiveEn(littleEndianList);
break;
case slave2Elements:
this->_beamFormerSlave2->elementActiveEn(littleEndianList);
break;
}
}
void TrxBoard::adcCaptureConfig(captureConfig& capCfg) const
{
//ADC capture config
this->_debugSlave0->adcLoggerConfig(capCfg);
this->_debugSlave1->adcLoggerConfig(capCfg);
this->_debugSlave2->adcLoggerConfig(capCfg);
}
void TrxBoard::adcCaptureStart(void) const
{
//ADC capture reset
this->_debugSlave0->adcLoggerRst(true);
this->_debugSlave1->adcLoggerRst(true);
this->_debugSlave2->adcLoggerRst(true);
this->_debugSlave0->adcLoggerRst(false);
this->_debugSlave1->adcLoggerRst(false);
this->_debugSlave2->adcLoggerRst(false);
//ADC capture start
adcCaptureStart(_debugSlave0);
adcCaptureStart(_debugSlave1);
adcCaptureStart(_debugSlave2);
}
void TrxBoard::setCaptureManualSync(void) const
{
this->_misc->setSyncMode(otherAdcLogMode);
this->_misc->setManualSync(true);
this->_misc->setManualSync(false);
this->_misc->setSyncMode(bfSyncMode);
}
void TrxBoard::adcCaptureDone(void)
{
if(MOUNTED_SLAVE_FPGA & 1)
{
waitForCaptureDone(_debugSlave0);
}
if(MOUNTED_SLAVE_FPGA & 2)
{
waitForCaptureDone(_debugSlave1);
}
if(MOUNTED_SLAVE_FPGA & 4)
{
waitForCaptureDone(_debugSlave2);
}
adcCaptureStop(_debugSlave0);
adcCaptureStop(_debugSlave1);
adcCaptureStop(_debugSlave2);
}
void TrxBoard::adcLoggerStart(const QString path, const QString fileName)
{
quint8 fpgaSel(0);
quint8 chNumPerFpga(0);
QTime t = QTime::currentTime();
QString logPath = path + "/" + fileName + "_adcLog" + QString("_%1_%2_%3.csv")
.arg(t.hour())
.arg(t.minute())
.arg(t.second());
QFile logFile(logPath);
QTextStream log(&logFile);
if(logPath.isEmpty())
{
throw HardwareException(AFE_ERROR, "No file has selected.");
}
if(!logFile.open(QIODevice::WriteOnly))
{
throw HardwareException(AFE_ERROR, "Couldn't open file for logging.");
}
log << "SYNC Offset(ns): ";
if(MOUNTED_SLAVE_FPGA & 1)
{
log << this->_debugSlave0->getCapSyncOffset() * 5 << ", ";
}
if(MOUNTED_SLAVE_FPGA & 2)
{
log << this->_debugSlave1->getCapSyncOffset() * 5 << ", ";
}
if(MOUNTED_SLAVE_FPGA & 4)
{
log << this->_debugSlave2->getCapSyncOffset() * 5;
}
log << endl;
log << "ADC Sample Latancy(ns): ";
if(MOUNTED_SLAVE_FPGA & 1)
{
log << this->_afeSlave0->getAdcLatency() * 2.5f << ", ";
}
if(MOUNTED_SLAVE_FPGA & 2)
{
log << this->_afeSlave1->getAdcLatency() * 2.5f << ", ";
}
if(MOUNTED_SLAVE_FPGA & 4)
{
log << this->_afeSlave2->getAdcLatency() * 2.5f;
}
log << endl;
log << "ADC Sample Logger Offset(sample): ";
if(MOUNTED_SLAVE_FPGA & 1)
{
log << this->_debugSlave0->getCaptureSampleNo() << ", ";
}
if(MOUNTED_SLAVE_FPGA & 2)
{
log << this->_debugSlave1->getCaptureSampleNo() << ", ";
}
if(MOUNTED_SLAVE_FPGA & 4)
{
log << this->_debugSlave2->getCaptureSampleNo();
}
log << endl;
//Set gt to adc mode.
this->_misc->setGtSendMode(adcMode);
//Stop adc log transfer.
this->_debugSlave0->adcLoggerTransferCmd(loggerStop);
this->_debugSlave1->adcLoggerTransferCmd(loggerStop);
this->_debugSlave2->adcLoggerTransferCmd(loggerStop);
quint8 afeChannelNum = AFE_CHANNEL_NUM_PER_SLAVE * (
((MOUNTED_SLAVE_FPGA & 4) >> 2) +
((MOUNTED_SLAVE_FPGA & 2) >> 1) +
(MOUNTED_SLAVE_FPGA & 1));
for(quint8 chNum = 0; chNum < afeChannelNum; chNum++)
{
fpgaSel = chNum / AFE_CHANNEL_NUM_PER_SLAVE;
chNumPerFpga = chNum % AFE_CHANNEL_NUM_PER_SLAVE;
//ADC sampler start according to selected fpga.
this->_misc->setAdcSamplerCmd(samplerStop);
this->_misc->setAdcSamplerFpgaSel(fpgaSel);
this->_misc->setAdcSamplerCmd(samplerStart);
switch(fpgaSel)
{
case 0:
this->adcLogTransferRoutine(_debugSlave0, chNumPerFpga);
break;
case 1:
this->adcLogTransferRoutine(_debugSlave1, chNumPerFpga);
break;
case 2:
this->adcLogTransferRoutine(_debugSlave2, chNumPerFpga);
break;
}
//Read adc data bram.
QList<qint16> adcDataList = this->_misc->getAdcDataBram();
foreach(auto data, adcDataList)
{
log << data << ',';
}
log << endl;
//ADC sampler stop.
this->_misc->setAdcSamplerCmd(samplerStop);
}
logFile.flush();
logFile.close();
//Set gt to beamformer mode.
this->_misc->setGtSendMode(bfMode);
}
void TrxBoard::setDebuggerMode(eDebugMode bfMode, bool enable)
{
DebugMode debug;
DebugMode debugRb;
debug.rxBfDbgModeEn = false;
debug.rxBfSimDataGenModeEn = false;
debug.txBfTestModeEn = enable;
debug.txBfTestModeCfg = bfMode;
this->debuggerMode(_debugSlave0, debug, debugRb, "slave0");
this->debuggerMode(_debugSlave1, debug, debugRb, "slave1");
this->debuggerMode(_debugSlave2, debug, debugRb, "slave2");
}
void TrxBoard::setAfeConfig(AfeConfig& afeCfg) const
{
this->_afeSlave0->setAfeParams(afeCfg);
this->_afeSlave1->setAfeParams(afeCfg);
this->_afeSlave2->setAfeParams(afeCfg);
}
void TrxBoard::setAfesPwr(eAfePwrdnMode pwrMode) const
{
this->_afeSlave0->setAfeGblPwr(pwrMode);
this->_afeSlave1->setAfeGblPwr(pwrMode);
this->_afeSlave2->setAfeGblPwr(pwrMode);
}
void TrxBoard::setAfesFastPwr(eAfePwrdnMode pwrMode) const
{
this->_afeSlave0->setAfeFastPwr(pwrMode);
this->_afeSlave1->setAfeFastPwr(pwrMode);
this->_afeSlave2->setAfeFastPwr(pwrMode);
}
void TrxBoard::setAfesHeartBeat(const bool heartBeat) const
{
this->_afeSlave0->setAfeHeartBeat(heartBeat);
this->_afeSlave1->setAfeHeartBeat(heartBeat);
this->_afeSlave2->setAfeHeartBeat(heartBeat);
}
void TrxBoard::afesHeartBeatDisable(const bool mode) const
{
this->_afeSlave0->heartBeatsDisable(mode);
this->_afeSlave1->heartBeatsDisable(mode);
this->_afeSlave2->heartBeatsDisable(mode);
}