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.
23 Commits
2 Branches
28 Tags
1.3 MiB
 
 
Tree: 8248ed6541
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8248ed6541'
${ noResults }
hardware-api/src/model/hardware/core/TrxBoard.cpp

1822 lines
54 KiB
Raw Blame History

#include "model/hardware/core/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::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 temp = QByteArray::fromRawData(_device.getBufferPtr(_swCounter), BUFFER_SIZE);
#ifdef DEVELOP_UI
emit sendFramePacket(temp);
#else
packetEngine.newData(temp);
#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
{
quint32 syncErr(0);
this->_bCtrlMngt->timerShot(20);
while(!(this->_bCtrlMngt->checkTimeout()));
this->_misc->setSyncMode(adcSyncMode);
this->_misc->setManualSync(true);
this->_misc->setManualSync(false);
this->_misc->setManualSync(bfSyncMode);
this->_bCtrlMngt->timerShot(1);
while(!((this->_afeSlave0->getAfeSyncDone()) &&
(this->_afeSlave1->getAfeSyncDone()) &&
(this->_afeSlave2->getAfeSyncDone())))
{
if(this->_bCtrlMngt->checkTimeout())
{
throw SonoException(
"The timeout of the afe adcs sync is happend without receiving of sync done.");
}
}
this->_bCtrlMngt->timerStop();
syncErr = this->_afeSlave0->getAfeSyncError();
syncErr += this->_afeSlave1->getAfeSyncError();
syncErr += this->_afeSlave2->getAfeSyncError();
if(syncErr != 0)
{
throw SonoException("The error of the afe adcs sync is happend.");
}
}
void TrxBoard::waitForCaptureDone(Debug *_dbg) const
{
// Timeout to receive adc capture done.
this->_bCtrlMngt->timerShot(1000);
while (!(_dbg->getCapDone()))
{
if(this->_bCtrlMngt->checkTimeout())
throw SonoException("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 SonoException("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 SonoException("Failure to receive adc sampler done.");
}
this->_bCtrlMngt->timerStop();
if (adcSamplerError)
throw SonoException("The adc sampler error is 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::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);
_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;
_allow = false;
_run = false;
setSwapVector();
setRomCrc();
setFpgaOffset();
setAfeModuleOffset();
}
TrxBoard::ScenHwRegister::ScenHwRegister()
{
configLut = new ReceiverConfiguration;
elementPosition = new ProbeElementPosition;
rxBeamformer = new RxBeamformerProperties;
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 _bpiFlash;
delete _emul;
delete _misc;
delete _sram;
delete _dsp;
delete _adc;
delete _pg;
delete _tachoRpm;
delete _coreVolt;
delete _coreTemp;
delete _scenParams;
}
TrxBoard::ScenHwRegister::~ScenHwRegister()
{
delete configLut;
delete rxBeamformer;
delete elementPosition;
delete pulse;
}
TrxBoard::ScenGenHardwareParam::~ScenGenHardwareParam()
{
delete hwRegister;
delete indexParams;
delete rxParams;
delete txParams;
}
void TrxBoard::init()
{
this->_device.init();
this->_bCtrlMngt->prbCtrlInit();
sramClear(all);
}
void TrxBoard::fpgaProgram(const QString path) const
{
if(MOUNTED_SLAVE_FPGA <= 0 || MOUNTED_SLAVE_FPGA >= 8)
{
throw SonoException("Wrong mounted slave fpga is selected");
}
QByteArray bitFileData;
QFile bitFile(path);
bitFileData.clear();
if(bitFile.fileName().isEmpty())
{
throw SonoException("No file is selected");
}
if(!bitFile.open(QIODevice::ReadOnly))
{
throw SonoException("Couldn't open bit file programming");
}
bitFileData = bitFile.readAll();
bitFile.close();
this->_fpgaProgram->program(bitFileData, MOUNTED_SLAVE_FPGA);
}
void TrxBoard::setProbeDependParams(ScenPrbDepHardwareParam& prbDepParams)
{
/////////////////////////// DSP setting ///////////////////////////
if(prbDepParams.prbDepParams.apodizationLut.size() != APODIZATIONLUT_LUT_MAX)
{
throw SonoException("Apodization lut is out of range");
}
QList<QList<quint32> > apodizationQ;
foreach(auto vec, prbDepParams.prbDepParams.apodizationLut)
{
apodizationQ.push_back(vec.toList());
}
this->_beamFormerSlave0->apodizationLut(apodizationQ);
this->_beamFormerSlave1->apodizationLut(apodizationQ);
this->_beamFormerSlave2->apodizationLut(apodizationQ);
scenParamsFilling(set);
if(prbDepParams.prbDepParams.atgcLut.size() != ATGC_LUT_MAX)
{
throw SonoException("Atgc lut is out of range");
}
QList<QList<quint32> > atgcLutQ;
foreach(auto vec, prbDepParams.prbDepParams.atgcLut)
{
atgcLutQ.push_back(vec.toList());
}
this->_dsp->atgcLut(atgcLutQ);
if(prbDepParams.prbDepParams.lpfLut.size() != LPF_LUT_MAX)
{
throw SonoException("Lpf lut is out of range");
}
QList<QList<quint32> > lpfLutQ;
foreach(auto vec, prbDepParams.prbDepParams.lpfLut)
{
lpfLutQ.push_back(vec.toList());
}
this->_dsp->lpfLut(lpfLutQ);
if(prbDepParams.prbDepParams.lpfScaleCoeff.size() != LPF_SCALE_MAX)
{
throw SonoException("Lpf scale coefficient is out of range");
}
this->_dsp->lpfScaleCoefficient(prbDepParams.prbDepParams.lpfScaleCoeff);
/////////////////////////// AFE setting ///////////////////////////
setAfeConfig (prbDepParams.afeCfg);
setAfePwr(afePwrdnEnable);
}
void TrxBoard::setScenario(ScenGenHardwareOutput_t& scenGenHw)
{
if(this->_scenPlayer->control.getCommand())
{
scenPlayerStop();
}
emulatorStop();
sramClear(first4M);
_scenParams->focusTypeNumber = scenGenHw.focusTypeNumber;
if(_scenParams->focusTypeNumber > FOCUS_TYPE_NUMBER_MAX)
{
throw SonoException("Focus type number is out of range");
}
_scenParams->totalTxShotNumber = scenGenHw.totalTxShotNumber;
if(_scenParams->totalTxShotNumber > TOTAL_TX_SHOT_NUMBER_MAX)
{
throw SonoException("Total tx shot number is out of range");
}
_scenParams->rxBeamFormerNumber = scenGenHw.rxBeamFormerNumber.toVector();
if(_scenParams->rxBeamFormerNumber.size() > RX_BEAMFORMER_NUMBER_MAX)
{
throw SonoException("Rx beam former number is out of range");
}
_scenParams->scenarioStartIndex = scenGenHw.hwRegister.scenarioStartIndex;
_scenParams->scenarioEndIndex = scenGenHw.hwRegister.scenarioEndIndex;
if(_scenParams->scenarioEndIndex > SCENARIO_INDEX_MAX)
{
throw SonoException("Scenario end index is out of range");
}
if(_scenParams->scenarioEndIndex < _scenParams->scenarioStartIndex)
{
throw SonoException(
"The scenario end index must be greater than or equal to the scenario start index");
}
if(_scenParams->scenarioEndIndex != (_scenParams->totalTxShotNumber - 1))
{
throw SonoException(
"The scenario end index must be equal to the total tx shot number minus one");
}
_scenParams->hwRegister->blendWeight = scenGenHw.hwRegister.blendWeight;
if(_scenParams->hwRegister->blendWeight.size() != BLENDWEIGHT_LUT_MAX)
{
throw SonoException("Blend weight lut is out of range");
}
_scenParams->hwRegister->elementPosition->xPosition = scenGenHw.hwRegister.elementXPosition;
if(_scenParams->hwRegister->elementPosition->xPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw SonoException("Element position x is out of range");
}
_scenParams->hwRegister->elementPosition->yPosition = scenGenHw.hwRegister.elementYPosition;
if(_scenParams->hwRegister->elementPosition->yPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw SonoException("Element position y is out of range");
}
_scenParams->hwRegister->elementPosition->zPosition = scenGenHw.hwRegister.elementZPosition;
if(_scenParams->hwRegister->elementPosition->zPosition.size() != ELEMENT_POSITION_LUT_MAX)
{
throw SonoException("Element position z is out of range");
}
_scenParams->hwRegister->freqLut = scenGenHw.hwRegister.freqLut;
if(_scenParams->hwRegister->freqLut.size() != FREQUENCY_LUT_MAX)
{
throw SonoException("Frequency lut is out of range");
}
_scenParams->hwRegister->dtgcLut = scenGenHw.hwRegister.dtgcLut;
if(_scenParams->hwRegister->dtgcLut.size() != DTGC_LUT_MAX)
{
throw SonoException("Dtgc lut is out of range");
}
_scenParams->hwRegister->pulseTypeNumber = scenGenHw.hwRegister.pulseTypeNumber;
if(_scenParams->hwRegister->pulseTypeNumber > PULSE_LUT_MAX)
{
throw SonoException("Pulse type number is out of range");
}
_scenParams->hwRegister->rxBeamFormerTypeNumber = scenGenHw.hwRegister.rxBeamFormerTypeNumber;
if(_scenParams->hwRegister->rxBeamFormerTypeNumber > RXBEAMFORMER_LUT_MAX)
{
throw SonoException("Rx beam former type number is out of range");
}
_scenParams->hwRegister->receiverConfigTypeNumber =
scenGenHw.hwRegister.receiverConfigTypeNumber;
if(_scenParams->hwRegister->receiverConfigTypeNumber > RRECEIVER_CONFIGURATION_LUT_MAX)
{
throw SonoException("Receiver config type number is out of range");
}
_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.ddcn);
_scenParams->hwRegister->configLut->dpeEn.append(k.dpeEn);
_scenParams->hwRegister->configLut->stbEn.append(k.stbEn);
_scenParams->hwRegister->configLut->wmfEn.append(k.wmfEn);
_scenParams->hwRegister->configLut->lpfSel.append(k.lpfSel);
_scenParams->hwRegister->configLut->aTgcSel.append(k.aTgcSel);
_scenParams->hwRegister->configLut->focusNo.append(k.focusNo);
_scenParams->hwRegister->configLut->lineMode.append(k.lineMode);
_scenParams->hwRegister->configLut->ncoFreqSel.append(k.ncoFreqSel);
_scenParams->hwRegister->configLut->dcCancelerEn.append(k.dcCancelEn);
_scenParams->hwRegister->configLut->lineFilterEn.append(k.lineFilterEn);
_scenParams->hwRegister->configLut->subtractFilterEn.append(k.subtractFilterEn);
}
_scenParams->indexParams->dLineNum = scenGenHw.indexParams.dLineNum;
_scenParams->indexParams->frameType = scenGenHw.frameType;
_scenParams->indexParams->dEnsembleNum = scenGenHw.indexParams.dEnsembleNum;
_scenParams->indexParams->lastLineInFrame = scenGenHw.indexParams.lastLineInFrame;
_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;
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->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->dtgcLut, 0, 12, 8, 0, true, false);
QList<quint32> dtgcLutQ = _unsignedQntzrVec.toList();
this->_dsp->dtgcLut(dtgcLutQ);
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);
///////////////////////////////// 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 SonoException("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 SonoException("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 SonoException("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) const
{
QList<quint64> data;
QByteArray temp;
qint32 num(0);
while(num < metaData.size())
{
for(quint8 j = 0; j < sizeof(quint64); j++)
{
temp.append(metaData[j + num]);
}
data.push_back(byteArray2UintLittleEndian<quint64>(temp));
temp.clear();
num += sizeof(quint64);
}
this->_sram->setSramMetaData(data);
}
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 SonoException("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 SonoException(
"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 SonoException(
"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 SonoException(
"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 SonoException("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->_bCtrlMngt->timerShot(1);
while(!(this->_bCtrlMngt->checkTimeout()));
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->_bCtrlMngt->timerShot(1);
while(!(this->_bCtrlMngt->checkTimeout()));
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->_bCtrlMngt->timerShot(1);
while(!(this->_bCtrlMngt->checkTimeout()));
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::slaveFpgaProgram(const QString path)
{
scenParamsFilling(clear);
fpgaProgram (path);
#ifndef DEVELOP_UI
afeAdcsSync();
#endif
}
void TrxBoard::setBeamFormerMode(eClkMode mode) const
{
this->_clkDistributer->clockMode(CLOCK_DIVISION, mode);
}
/* set afeHvPwrOn true when unfreeze happen */
void TrxBoard::scenPlayerStart(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);
this->_bCtrlMngt->timerShot(20);
//uncrustify off
while(!(this->_bCtrlMngt->checkTimeout()));
//uncrustify on
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOn();
#endif
}
this->_scenPlayer->control.setCommand(true);
_run = true;
QtConcurrent::run(this, &TrxBoard::readData);
}
else
{
throw SonoException("Total scenario luts and sram parameters are not written compeletely");
}
}
/* set afeHvPwrOff true when freeze happen */
void TrxBoard::scenPlayerStop(bool afeHvPwrOff)
{
_run = false;
this->_device.stopDma();
this->_scenPlayer->control.setCommand(false);
if(afeHvPwrOff)
{
this->_afeSlave0->setAfeGblPwr(afePwrdnEnable);
this->_afeSlave1->setAfeGblPwr(afePwrdnEnable);
this->_afeSlave2->setAfeGblPwr(afePwrdnEnable);
#ifdef MPS_BOARD
this->_bCtrlMngt->mpsDacsOff();
#endif
this->_bCtrlMngt->timerShot(20);
//uncrustify off
while(!(this->_bCtrlMngt->checkTimeout()));
//uncrustify on
}
}
//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 SonoException("No file is selected");
}
if(!emulFile.open(QIODevice::ReadOnly))
{
throw SonoException("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();
_run = true;
QtConcurrent::run(this, &TrxBoard::readData);
}
void TrxBoard::emulatorStop()
{
_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::trxState(EepromStatus& romStatus) const
{
QByteArray id;
QByteArray crcChk;
romStatus.ConnectionMode = connected;
id = this->_bCtrlMngt->trxEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER);
romStatus.id = byteArray2UintBigEndian<quint16>(id);
crcChk = this->_bCtrlMngt->trxEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER);
if(crcChk == _eepromCrc)
{
romStatus.errorCode = EEPROM_NO_ERROR;
}
else
{
romStatus.errorCode = EEPROM_CRC_ERROR;
}
}
void TrxBoard::mpsState(EepromStatus& romStatus) const
{
QByteArray id;
QByteArray crcChk;
romStatus.ConnectionMode = connected;
id = this->_bCtrlMngt->mpsEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER);
romStatus.id = byteArray2UintBigEndian<quint16>(id);
crcChk = this->_bCtrlMngt->mpsEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER);
if(crcChk == _eepromCrc)
{
romStatus.errorCode = EEPROM_NO_ERROR;
}
else
{
romStatus.errorCode = EEPROM_CRC_ERROR;
}
}
void TrxBoard::prbCtrlState(EepromStatus& romStatus) const
{
QByteArray id;
QByteArray crcChk;
romStatus.ConnectionMode = connected;
id = this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_ID_BEGIN, EEPROM_ID_NUMBER);
romStatus.id = byteArray2UintBigEndian<quint16>(id);
crcChk = this->_bCtrlMngt->prbCtrlEepromRead(EEPROM_CRC_BEGIN, EEPROM_CRC_NUMBER);
if(crcChk == _eepromCrc)
{
romStatus.errorCode = EEPROM_NO_ERROR;
}
else
{
romStatus.errorCode = EEPROM_CRC_ERROR;
}
}
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 SonoException("This probe is disconnected");
}
if(prbSel == prbB && !vec.at(1))
{
throw SonoException("This probe is disconnected");
}
if(prbSel == prbC && !vec.at(2))
{
throw SonoException("This probe is disconnected");
}
if(prbSel == prbD && !vec.at(3))
{
throw SonoException("This probe is 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();
}
void TrxBoard::mcsProgram(QString path)
{
QFile mcsFile(path);
if(mcsFile.fileName().isEmpty())
{
throw SonoException("No file is selected");
}
if(!mcsFile.open(QIODevice::ReadOnly))
{
throw SonoException("Couldn't open mcs file programming");
}
QByteArray mcsFileData = mcsFile.readAll();
this->_bpiFlash->writeMcs(mcsFileData);
mcsFileData.clear();
mcsFile.close();
scenParamsFilling(clear);
}
void TrxBoard::mcsVerify(QString path) const
{
QList<quint32> mcsList;
QFile mcsFile(path + ".bin");
if(mcsFile.fileName().isEmpty())
{
throw SonoException("No file is selected");
}
if(!mcsFile.open(QIODevice::WriteOnly))
{
throw SonoException("Couldn't open mcs file programming");
}
QTextStream save(&mcsFile);
mcsList = this->_bpiFlash->readMcs();
for(auto i = 0; i < MCS_FILE_SIZE; i++)
{
save << (mcsList).at(i);
}
mcsFile.flush();
mcsFile.close();
}
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::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) const
{
waitForCaptureDone(_debugSlave0);
waitForCaptureDone(_debugSlave1);
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(logFile.fileName().isEmpty())
{
throw SonoException("No file is selected");
}
if(!logFile.open(QIODevice::WriteOnly))
{
throw SonoException("Couldn't open file for logging");
}
log << "SYNC Offset(ns): ";
log << this->_debugSlave0->getCapSyncOffset() * 5 << ", ";
log << this->_debugSlave1->getCapSyncOffset() * 5 << ", ";
log << this->_debugSlave2->getCapSyncOffset() * 5 << endl;
log << "ADC Sample Latancy(ns): ";
log << this->_afeSlave0->getAdcLatency() * 2.5f << ", ";
log << this->_afeSlave1->getAdcLatency() * 2.5f << ", ";
log << this->_afeSlave2->getAdcLatency() * 2.5f << endl;
log << "ADC Sample Logger Offset(sample): ";
log << this->_debugSlave0->getCaptureSampleNo() << ", ";
log << this->_debugSlave1->getCaptureSampleNo() << ", ";
log << this->_debugSlave2->getCaptureSampleNo() << 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);
for (quint8 chNum = 0; chNum < TOTAL_AFE_CHANNEL_NUM; 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::setAfePwr(eAfePwrdnMode pwrMode) const
{
this->_afeSlave0->setAfeGblPwr(pwrMode);
this->_afeSlave1->setAfeGblPwr(pwrMode);
this->_afeSlave2->setAfeGblPwr(pwrMode);
}