1 #include "otsdaq-components/DAQHardware/FSSRFirmwareBase.h"
3 #include "otsdaq-core/Macros/CoutMacros.h"
4 #include "otsdaq-core/MessageFacility/MessageFacility.h"
6 #include "otsdaq-components/DAQHardware/FSSRFirmwareDefinitions.h"
7 #include "otsdaq-components/DetectorHardware/FSSRROCDefinitions.h"
8 #include "otsdaq-core/BitManipulator/BitManipulator.h"
10 #include <arpa/inet.h>
11 #include <netinet/in.h>
12 #include <sys/socket.h>
17 #include "otsdaq-components/DAQHardware/FrontEndFirmwareBase.h"
18 #include "otsdaq-components/DAQHardware/OtsUDPFirmwareCore.h"
19 #include "otsdaq-components/DAQHardware/PurdueFirmwareCore.h"
23 const std::string FSSRFirmwareBase::PURDUE_FIRMWARE_NAME =
"PurdueFSSRFirmware";
24 const std::string FSSRFirmwareBase::OTS_FIRMWARE_NAME =
"OtsUDPFSSRFirmware";
27 FSSRFirmwareBase::FSSRFirmwareBase(
const std::string& communicationFirmwareType,
28 unsigned int communicationFirmwareVersion,
30 : stripCSRRegisterValue_(0), communicationFirmwareType_(communicationFirmwareType)
33 if(communicationFirmwareType ==
34 FSSRFirmwareBase::PURDUE_FIRMWARE_NAME)
36 communicationFirmwareInstance_ =
38 else if(communicationFirmwareType ==
39 FSSRFirmwareBase::OTS_FIRMWARE_NAME)
44 communicationFirmwareInstance_ =
48 __SS__ <<
"Unknown communication firmware type choice: "
49 << communicationFirmwareType << std::endl;
50 __COUT_ERR__ << ss.str();
60 FSSRFirmwareBase::~FSSRFirmwareBase(
void)
62 delete communicationFirmwareInstance_;
63 communicationFirmwareInstance_ = NULL;
67 void FSSRFirmwareBase::init(
void) {}
70 std::string FSSRFirmwareBase::universalRead(
char* address)
72 __COUT__ <<
"universalRead communicationFirmwareType_ " << communicationFirmwareType_
74 return communicationFirmwareInstance_->read(address);
78 std::string FSSRFirmwareBase::universalWrite(
char* address,
char* data)
80 __COUT__ <<
"universalWrite communicationFirmwareType_ " << communicationFirmwareType_
82 return communicationFirmwareInstance_->write(address, data);
86 uint32_t FSSRFirmwareBase::createRegisterFromValue(std::string& readBuffer,
87 std::string& receivedValue)
89 return communicationFirmwareInstance_->createRegisterFromValue(readBuffer,
94 std::string FSSRFirmwareBase::configureClocks(std::string source,
double frequency)
102 setPacketSizeStripCSR(6);
103 setExternalBCOClockSourceStripCSR(source);
104 communicationFirmwareInstance_->write(
105 buffer, STRIP_CSR, stripCSRRegisterValue_);
111 setFrequencyFromClockState(buffer, frequency);
112 communicationFirmwareInstance_->write(
113 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
123 void FSSRFirmwareBase::resetDCM(std::string& buffer)
126 resetDCMStripCSR(
true);
127 communicationFirmwareInstance_->write(buffer,
129 stripCSRRegisterValue_,
132 resetDCMStripCSR(
false);
133 communicationFirmwareInstance_->write(buffer,
135 stripCSRRegisterValue_,
144 void FSSRFirmwareBase::alignReadOut(std::string& buffer,
154 communicationFirmwareInstance_->write(
157 (0x9 << 28) + ((chip & 0xf) << 3) +
161 std::string FSSRFirmwareBase::resetDetector(
int channel)
186 communicationFirmwareInstance_->write(
198 communicationFirmwareInstance_->write(
212 std::string FSSRFirmwareBase::enableTrigger(
void)
221 sendTriggerDataStripCSR(
false);
222 communicationFirmwareInstance_->write(
223 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
224 resetTriggerCounterStripCSR(buffer);
225 sendTriggerDataStripCSR(
true);
226 sendTriggerNumberStripCSR(
true);
227 sendBCOStripCSR(
true);
228 communicationFirmwareInstance_->write(
229 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
231 stripTriggerCSRRegisterValue_ = 0;
233 communicationFirmwareInstance_->write(
236 stripTriggerCSRRegisterValue_,
244 configureStripTriggerUnbiased(buffer);
246 configureTriggerInputs(buffer);
251 communicationFirmwareInstance_->write(
252 buffer, STRIP_TRIG_INPUT_3, 0x20401000,
false );
294 std::string FSSRFirmwareBase::resetBCO(
void)
296 std::cout << __COUT_HDR_PL__ <<
"Reset BCO!!!" << std::endl;
297 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue in :" << std::hex
298 << stripCSRRegisterValue_ << std::dec << std::endl;
340 communicationFirmwareInstance_->write(
341 buffer, STRIP_SC_CSR, 0x903f0b95,
false );
350 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue out:" << std::hex
351 << stripCSRRegisterValue_ << std::dec << std::endl;
352 std::cout << __COUT_HDR_FL__ <<
"Done reset BCO!!!" << std::endl;
358 std::string FSSRFirmwareBase::armBCOReset(
void)
362 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
367 std::string FSSRFirmwareBase::startStream(
bool channel0,
383 enableChannelsStripCSR(channel0, channel1, channel2, channel3, channel4, channel5);
389 enableStreamStripCSR(
391 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
401 std::string FSSRFirmwareBase::stopStream(
void)
404 enableStreamStripCSR(
false);
405 enableChannelsStripCSR(
false,
false,
false,
false,
false,
false);
406 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
412 unsigned int channel,
415 const ROCDACs& rocDACs = rocStream.getROCDACs();
416 for(DACList::const_iterator it = rocDACs.getDACList().begin();
417 it != rocDACs.getDACList().end();
421 uint64_t data = FSSRROCDefinitions::makeDACWriteCommand(
422 rocStream.getFEWROCAddress(), it->first, it->second.second);
423 sequence.pushBack(ChannelFIFOAddress[channel], data);
424 sequence.pushBack(ChannelFIFOAddress[channel],
425 BitManipulator::insertBits(data, (uint64_t)0x48, 56, 8));
427 sequence.pushBack(ChannelFIFOAddress[channel],
428 BitManipulator::insertBits(data, (uint64_t)1, 60, 1));
430 sequence.pushBack(ChannelFIFOAddress[channel],
431 BitManipulator::insertBits(data, (uint64_t)0, 60, 1));
433 sequence.pushBack(ChannelFIFOAddress[channel],
434 BitManipulator::insertBits(data, (uint64_t)0, 62, 1));
435 sequence.pushBack(ChannelFIFOAddress[channel],
436 BitManipulator::insertBits(data, (uint64_t)0x40, 56, 8));
443 unsigned int channel,
446 const ROCDACs& rocDACs = rocStream.getROCDACs();
447 for(DACList::const_iterator it = rocDACs.getDACList().begin();
448 it != rocDACs.getDACList().end();
472 uint32_t data = FSSRROCDefinitions::makeDACWriteHeader(
473 rocStream.getFEWROCAddress(), it->first);
475 BitManipulator::insertBits(data, 1, 16 + channel, 1);
476 sequence.pushBack(ChannelFIFOAddress[channel], it->second.second);
477 std::cout << __COUT_HDR_FL__ <<
"Register: " << it->first
478 <<
" value: " << it->second.second << std::hex <<
" -> Data: " << data
479 << std::dec << std::endl;
480 sequence.pushBack(STRIP_SC_CSR, data);
486 unsigned int channel,
489 std::cout << __COUT_HDR_FL__ <<
"Channel: " << channel << std::endl;
490 std::cout << __COUT_HDR_FL__ <<
"BufferINsize: " << buffer.size() << std::endl;
491 const ROCDACs& rocDACs = rocStream.getROCDACs();
538 for(DACList::const_iterator it = rocDACs.getDACList().begin();
539 it != rocDACs.getDACList().end();
542 std::string bufferElement;
543 communicationFirmwareInstance_->waitClear(
544 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
545 uint32_t registerHeader = 0;
547 if(it->first !=
"RejectHits" && it->first !=
"SendData")
549 communicationFirmwareInstance_->write(
550 bufferElement, ChannelFIFOAddress[channel], it->second.second,
false);
551 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(
552 rocStream.getFEWROCAddress(), it->first);
554 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
558 if(it->second.second == 1 || it->second.second == 2)
560 registerHeader = FSSRROCDefinitions::makeDACSetHeader(
561 rocStream.getFEWROCAddress(), it->first);
563 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
565 else if(it->second.second == 0 || it->second.second == 5)
567 registerHeader = FSSRROCDefinitions::makeDACResetHeader(
568 rocStream.getFEWROCAddress(), it->first);
570 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
573 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it->first
574 <<
" doesn't have a value I expect -> value = "
575 << it->second.second << std::endl;
581 communicationFirmwareInstance_->write(
582 bufferElement, STRIP_SC_CSR, registerHeader,
false);
583 communicationFirmwareInstance_->waitClear(
584 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
587 buffer += bufferElement;
590 std::cout << __COUT_HDR_FL__ <<
"BufferOUTsize: " << buffer.size() << std::endl;
595 unsigned int channel,
601 unsigned int singleVectorCount = 0;
603 std::string alternateBuffer;
606 const ROCDACs& rocDACs = rocStream.getROCDACs();
609 std::string bufferElement;
612 for(
const std::pair<std::string, std::pair<unsigned int, unsigned int> >& it :
613 rocDACs.getDACList())
621 communicationFirmwareInstance_->waitClear(
622 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
623 uint32_t registerHeader = 0;
626 if(it.first !=
"RejectHits" && it.first !=
"SendData")
630 communicationFirmwareInstance_->write(
631 bufferElement, ChannelFIFOAddress[channel], it.second.second,
false);
632 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(
633 rocStream.getFEWROCAddress(), it.first);
635 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
640 if(it.second.second == 1 || it.second.second == 2)
642 registerHeader = FSSRROCDefinitions::makeDACSetHeader(
643 rocStream.getFEWROCAddress(), it.first);
645 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
647 else if(it.second.second == 0 || it.second.second == 5)
649 registerHeader = FSSRROCDefinitions::makeDACResetHeader(
650 rocStream.getFEWROCAddress(), it.first);
652 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
655 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it.first
656 <<
" doesn't have a value I expect -> value = "
657 << it.second.second << std::endl;
662 communicationFirmwareInstance_->write(
663 bufferElement, STRIP_SC_CSR, registerHeader,
false);
664 communicationFirmwareInstance_->waitClear(
665 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
672 if(limitCount == STIB_DAC_WRITE_MAX)
674 std::cout << __COUT_HDR_FL__ <<
"\tBuffer length:" << bufferElement.size()
676 buffer.push_back(bufferElement);
678 bufferElement.clear();
680 else if(singleVectorCount ==
681 rocDACs.getDACList().size())
683 buffer.push_back(bufferElement);
693 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
694 unsigned int channel,
698 makeMaskBuffer(buffer, channel, rocStream,
"Kill");
703 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
704 unsigned int channel,
706 const std::string& registerName)
708 int chipId = rocStream.getFEWROCAddress();
709 const std::string& mask = rocStream.getROCMask();
714 unsigned int data[4] = {0, 0, 0, 0};
718 for(
unsigned int d = 0; d < 4; d++)
722 for(
unsigned int m = 0; m < 8 * 4; m++)
724 val = mask[(8 * 4 * d) + m];
730 data[d] |= (
unsigned int)atoi(&val) << (8 * 4 - 1 - m);
744 unsigned char len = 4;
745 unsigned char addr = 17;
746 unsigned char bitMask = 1 << channel;
747 unsigned char inst = WRITE;
749 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
751 for(i = 0; i < 4; i++)
753 communicationFirmwareInstance_->write(
754 buffer, STRIP_SCI + 4 * (4 - i - 1), data[i],
false);
756 w = 0x80000000 | (len << 24) | (bitMask << 16) | (inst << 10) | (addr << 5) | chipId;
758 communicationFirmwareInstance_->write(buffer, STRIP_SC_CSR, w,
false);
760 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
765 unsigned int channel,
768 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
769 makeMaskSequence(sequence, channel, rocStream,
"Kill");
775 unsigned int channel,
778 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
779 makeMaskSequence(sequence, channel, rocStream,
"Kill");
785 unsigned int channel,
787 const std::string& registerName)
789 int chipId = rocStream.getFEWROCAddress();
790 std::string mask = rocStream.getROCMask();
791 std::cout << __COUT_HDR_FL__ <<
"Mask length: " << mask.length() << std::endl;
793 uint64_t uInt64Data = 0;
794 std::string stringData =
"";
811 BitManipulator::insertBits(uInt64Data, 0x1, 56, 8);
812 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
815 BitManipulator::insertBits(uInt64Data, 0x2, 56, 8);
816 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
822 BitManipulator::insertBits(uInt64Data, 0x40, 16, 8);
823 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
824 BitManipulator::insertBits(
829 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
831 stringData = FSSRROCDefinitions::makeMaskWriteCommand(chipId, registerName, mask);
834 for(
unsigned int s = 0; s < stringData.length(); s++)
835 for(
int b = 8 - 1; b >= 0 && (s * 8 + 8 - b < 13 + 128); b--)
840 data = 0x40 | (((stringData.data()[s] >> b) & 1) << 5);
841 BitManipulator::insertBits(uInt64Data, (uint64_t)data, 16, 8);
842 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
844 BitManipulator::insertBits(uInt64Data, (uint64_t)data, 16, 8);
845 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
849 BitManipulator::insertBits(uInt64Data, 0x0, 16, 8);
850 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
851 BitManipulator::insertBits(uInt64Data, 0x80, 16, 8);
852 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
855 BitManipulator::insertBits(uInt64Data, 0x0, 56, 8);
856 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
859 BitManipulator::insertBits(uInt64Data, 0x80, 56, 8);
860 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
865 unsigned int channel,
867 const std::string& registerName)
872 std::string FSSRFirmwareBase::readCSRRegister()
876 communicationFirmwareInstance_->read(buffer, STRIP_CSR);
881 std::string FSSRFirmwareBase::readSCCSRRegister()
884 std::cout << __COUT_HDR_FL__ <<
"FSSR readCSRRegister" << std::endl;
885 communicationFirmwareInstance_->read(buffer, STRIP_SC_CSR);
890 void FSSRFirmwareBase::setFrequencyFromClockState(std::string& buffer,
double frequency)
897 double realClockFrequency;
899 if(BitManipulator::readBits(stripCSRRegisterValue_, 17, 1) ==
905 if(isClockStateExternal())
908 EXTERNAL_CLOCK_FREQUENCY / quotient;
913 INTERNAL_CLOCK_FREQUENCY / quotient;
916 double factor = frequency / realClockFrequency;
931 int rest = denominator;
954 }
while(denominator >= 32 || numerator >= 32);
960 setFrequencyRatio(buffer, numerator, denominator);
964 bool FSSRFirmwareBase::isClockStateExternal()
967 if(BitManipulator::readBits(stripCSRRegisterValue_, 16, 1) == 1)
974 void FSSRFirmwareBase::setCSRRegister(uint32_t total) { stripCSRRegisterValue_ = total; }
977 void FSSRFirmwareBase::setPacketSizeStripCSR(uint32_t size)
980 std::cout << __COUT_HDR_FL__
981 <<
"ERROR: Maximum packet size is 31 while here you are trying to set "
982 << size <<
" packets!" << std::endl;
983 BitManipulator::insertBits(stripCSRRegisterValue_, size, 3, 5);
988 void FSSRFirmwareBase::enableChannelsStripCSR(
bool channel0,
995 BitManipulator::insertBits(stripCSRRegisterValue_,
996 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
997 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
998 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1004 void FSSRFirmwareBase::setExternalBCOClockSourceStripCSR(std::string clockSource)
1006 if(clockSource ==
"External")
1007 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 16, 1);
1008 else if(clockSource ==
"Internal")
1009 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 16, 1);
1019 void FSSRFirmwareBase::armBCOResetCSR(
void)
1021 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 19, 1);
1025 void FSSRFirmwareBase::flushBuffersStripCSR(
void)
1027 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 20, 1);
1031 void FSSRFirmwareBase::resetTriggerCounterStripCSR(std::string& buffer)
1034 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1035 communicationFirmwareInstance_->write(
1036 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1037 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1038 communicationFirmwareInstance_->write(
1039 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1040 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1041 communicationFirmwareInstance_->write(
1042 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1043 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1044 communicationFirmwareInstance_->write(
1045 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1046 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1047 communicationFirmwareInstance_->write(
1048 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1050 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 21, 1);
1051 communicationFirmwareInstance_->write(
1052 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1056 void FSSRFirmwareBase::resetBCOCounterStripCSR(
void)
1058 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 22, 1);
1062 void FSSRFirmwareBase::enableTriggerStripCSR(
bool enable)
1064 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)enable, 23, 1);
1068 void FSSRFirmwareBase::sendTriggerDataStripCSR(
bool send)
1070 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 24, 1);
1074 void FSSRFirmwareBase::sendTriggerNumberStripCSR(
bool send)
1076 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 25, 1);
1080 void FSSRFirmwareBase::sendBCOStripCSR(
bool send)
1082 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 26, 1);
1086 void FSSRFirmwareBase::enableStreamStripCSR(
bool enable)
1088 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)enable, 27, 1);
1092 void FSSRFirmwareBase::resetDCMStripCSR(
bool clear)
1094 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)clear, 31, 1);
1098 uint32_t FSSRFirmwareBase::waitDCMResetStripCSR(
void)
1100 uint32_t bitToCheck = 0;
1101 BitManipulator::insertBits(bitToCheck, 1, 31, 2);
1106 void FSSRFirmwareBase::resetDAC(
void)
1108 BitManipulator::insertBits(stripResetRegisterValue_, 1, 27, 1);
1112 void FSSRFirmwareBase::resetLink(
bool channel0,
1119 stripResetRegisterValue_ = 0;
1120 BitManipulator::insertBits(stripResetRegisterValue_,
1121 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1122 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1123 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1126 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
1140 void FSSRFirmwareBase::clearErrors(
bool channel0,
1147 stripResetRegisterValue_ = 0;
1148 BitManipulator::insertBits(stripResetRegisterValue_,
1149 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1150 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1151 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1154 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
1158 void FSSRFirmwareBase::clearFIFO(
bool channel0,
1165 stripResetRegisterValue_ = 0;
1166 BitManipulator::insertBits(stripResetRegisterValue_,
1167 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1168 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1169 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1172 BitManipulator::insertBits(stripResetRegisterValue_, 1, 30, 1);
1176 void FSSRFirmwareBase::resetChip(
bool channel0,
1183 stripResetRegisterValue_ = 0;
1184 BitManipulator::insertBits(stripResetRegisterValue_,
1185 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1186 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1187 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1190 BitManipulator::insertBits(stripResetRegisterValue_, 1, 31, 1);
1194 void FSSRFirmwareBase::setFrequencyRatio(std::string& buffer,
1200 communicationFirmwareInstance_->write(
1203 0x80500000 + (numerator - 1));
1204 communicationFirmwareInstance_->waitClear(
1209 communicationFirmwareInstance_->write(
1212 0x80520000 + (denominator - 1));
1213 communicationFirmwareInstance_->waitClear(
1214 buffer, STRIP_BCO_DCM, 0xf0000000);
1219 void FSSRFirmwareBase::BCOOffset(uint32_t offset)
1221 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, offset, 0, 4);
1225 void FSSRFirmwareBase::selectSpyFIFO(uint32_t input)
1227 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, input, 4, 3);
1231 void FSSRFirmwareBase::halt(
bool halt)
1233 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, (uint32_t)halt, 7, 1);
1237 void FSSRFirmwareBase::configureStripTriggerUnbiased(std::string& buffer)
1239 communicationFirmwareInstance_->write(
1241 STRIP_TRIG_UNBIASED,
1247 void FSSRFirmwareBase::configureTriggerInputs(std::string& buffer)
1253 communicationFirmwareInstance_->write(
1258 communicationFirmwareInstance_->write(
1263 communicationFirmwareInstance_->write(
1271 std::string FSSRFirmwareBase::resetSlaveBCO(
void)
1275 communicationFirmwareInstance_->write(
1276 buffer, (uint32_t)0xc5000000, (uint32_t)0x00000008);
void makeDACBuffer(std::string &buffer, unsigned int channel, const ROCStream &rocStream)