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 __COUT__ <<
"Reset BCO!!!" << std::endl;
297 __COUT__ <<
"stripCSRRegisterValue in :" << std::hex << stripCSRRegisterValue_
298 << std::dec << std::endl;
340 communicationFirmwareInstance_->write(
341 buffer, STRIP_SC_CSR, 0x903f0b95,
false );
350 __COUT__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_
351 << std::dec << std::endl;
352 __COUT__ <<
"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 __COUT__ <<
"Register: " << it->first <<
" value: " << it->second.second
478 << std::hex <<
" -> Data: " << data << std::dec << std::endl;
479 sequence.pushBack(STRIP_SC_CSR, data);
485 unsigned int channel,
488 __COUT__ <<
"Channel: " << channel << std::endl;
489 __COUT__ <<
"BufferINsize: " << buffer.size() << std::endl;
490 const ROCDACs& rocDACs = rocStream.getROCDACs();
537 for(DACList::const_iterator it = rocDACs.getDACList().begin();
538 it != rocDACs.getDACList().end();
541 std::string bufferElement;
542 communicationFirmwareInstance_->waitClear(
543 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
544 uint32_t registerHeader = 0;
546 if(it->first !=
"RejectHits" && it->first !=
"SendData")
548 communicationFirmwareInstance_->write(
549 bufferElement, ChannelFIFOAddress[channel], it->second.second,
false);
550 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(
551 rocStream.getFEWROCAddress(), it->first);
553 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
557 if(it->second.second == 1 || it->second.second == 2)
559 registerHeader = FSSRROCDefinitions::makeDACSetHeader(
560 rocStream.getFEWROCAddress(), it->first);
562 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
564 else if(it->second.second == 0 || it->second.second == 5)
566 registerHeader = FSSRROCDefinitions::makeDACResetHeader(
567 rocStream.getFEWROCAddress(), it->first);
569 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
572 __COUT__ <<
"Register value for : " << it->first
573 <<
" doesn't have a value I expect -> value = "
574 << it->second.second << std::endl;
580 communicationFirmwareInstance_->write(
581 bufferElement, STRIP_SC_CSR, registerHeader,
false);
582 communicationFirmwareInstance_->waitClear(
583 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
586 buffer += bufferElement;
589 __COUT__ <<
"BufferOUTsize: " << buffer.size() << std::endl;
594 unsigned int channel,
600 unsigned int singleVectorCount = 0;
602 std::string alternateBuffer;
605 const ROCDACs& rocDACs = rocStream.getROCDACs();
608 std::string bufferElement;
611 for(
const std::pair<std::string, std::pair<unsigned int, unsigned int> >& it :
612 rocDACs.getDACList())
620 communicationFirmwareInstance_->waitClear(
621 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
622 uint32_t registerHeader = 0;
625 if(it.first !=
"RejectHits" && it.first !=
"SendData")
629 communicationFirmwareInstance_->write(
630 bufferElement, ChannelFIFOAddress[channel], it.second.second,
false);
631 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(
632 rocStream.getFEWROCAddress(), it.first);
634 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
639 if(it.second.second == 1 || it.second.second == 2)
641 registerHeader = FSSRROCDefinitions::makeDACSetHeader(
642 rocStream.getFEWROCAddress(), it.first);
644 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
646 else if(it.second.second == 0 || it.second.second == 5)
648 registerHeader = FSSRROCDefinitions::makeDACResetHeader(
649 rocStream.getFEWROCAddress(), it.first);
651 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
654 __COUT__ <<
"Register value for : " << it.first
655 <<
" doesn't have a value I expect -> value = "
656 << it.second.second << std::endl;
661 communicationFirmwareInstance_->write(
662 bufferElement, STRIP_SC_CSR, registerHeader,
false);
663 communicationFirmwareInstance_->waitClear(
664 bufferElement, STRIP_SC_CSR, 0x80000000,
false);
671 if(limitCount == STIB_DAC_WRITE_MAX)
673 __COUT__ <<
"\tBuffer length:" << bufferElement.size() << std::endl;
674 buffer.push_back(bufferElement);
676 bufferElement.clear();
678 else if(singleVectorCount ==
679 rocDACs.getDACList().size())
681 buffer.push_back(bufferElement);
691 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
692 unsigned int channel,
696 makeMaskBuffer(buffer, channel, rocStream,
"Kill");
701 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
702 unsigned int channel,
704 const std::string& registerName)
706 int chipId = rocStream.getFEWROCAddress();
707 const std::string& mask = rocStream.getROCMask();
712 unsigned int data[4] = {0, 0, 0, 0};
716 for(
unsigned int d = 0; d < 4; d++)
720 for(
unsigned int m = 0; m < 8 * 4; m++)
722 val = mask[(8 * 4 * d) + m];
728 data[d] |= (
unsigned int)atoi(&val) << (8 * 4 - 1 - m);
742 unsigned char len = 4;
743 unsigned char addr = 17;
744 unsigned char bitMask = 1 << channel;
745 unsigned char inst = WRITE;
747 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
749 for(i = 0; i < 4; i++)
751 communicationFirmwareInstance_->write(
752 buffer, STRIP_SCI + 4 * (4 - i - 1), data[i],
false);
754 w = 0x80000000 | (len << 24) | (bitMask << 16) | (inst << 10) | (addr << 5) | chipId;
756 communicationFirmwareInstance_->write(buffer, STRIP_SC_CSR, w,
false);
758 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
763 unsigned int channel,
766 __COUT__ <<
"Making mask! " << std::endl;
767 makeMaskSequence(sequence, channel, rocStream,
"Kill");
773 unsigned int channel,
776 __COUT__ <<
"Making mask! " << std::endl;
777 makeMaskSequence(sequence, channel, rocStream,
"Kill");
783 unsigned int channel,
785 const std::string& registerName)
787 int chipId = rocStream.getFEWROCAddress();
788 std::string mask = rocStream.getROCMask();
789 __COUT__ <<
"Mask length: " << mask.length() << std::endl;
791 uint64_t uInt64Data = 0;
792 std::string stringData =
"";
809 BitManipulator::insertBits(uInt64Data, 0x1, 56, 8);
810 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
813 BitManipulator::insertBits(uInt64Data, 0x2, 56, 8);
814 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
820 BitManipulator::insertBits(uInt64Data, 0x40, 16, 8);
821 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
822 BitManipulator::insertBits(
827 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
829 stringData = FSSRROCDefinitions::makeMaskWriteCommand(chipId, registerName, mask);
832 for(
unsigned int s = 0; s < stringData.length(); s++)
833 for(
int b = 8 - 1; b >= 0 && (s * 8 + 8 - b < 13 + 128); b--)
838 data = 0x40 | (((stringData.data()[s] >> b) & 1) << 5);
839 BitManipulator::insertBits(uInt64Data, (uint64_t)data, 16, 8);
840 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
842 BitManipulator::insertBits(uInt64Data, (uint64_t)data, 16, 8);
843 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
847 BitManipulator::insertBits(uInt64Data, 0x0, 16, 8);
848 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
849 BitManipulator::insertBits(uInt64Data, 0x80, 16, 8);
850 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
853 BitManipulator::insertBits(uInt64Data, 0x0, 56, 8);
854 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
857 BitManipulator::insertBits(uInt64Data, 0x80, 56, 8);
858 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
863 unsigned int channel,
865 const std::string& registerName)
870 std::string FSSRFirmwareBase::readCSRRegister()
874 communicationFirmwareInstance_->read(buffer, STRIP_CSR);
879 std::string FSSRFirmwareBase::readSCCSRRegister()
882 __COUT__ <<
"FSSR readCSRRegister" << std::endl;
883 communicationFirmwareInstance_->read(buffer, STRIP_SC_CSR);
888 void FSSRFirmwareBase::setFrequencyFromClockState(std::string& buffer,
double frequency)
895 double realClockFrequency;
897 if(BitManipulator::readBits(stripCSRRegisterValue_, 17, 1) ==
903 if(isClockStateExternal())
906 EXTERNAL_CLOCK_FREQUENCY / quotient;
911 INTERNAL_CLOCK_FREQUENCY / quotient;
914 double factor = frequency / realClockFrequency;
929 int rest = denominator;
952 }
while(denominator >= 32 || numerator >= 32);
958 setFrequencyRatio(buffer, numerator, denominator);
962 bool FSSRFirmwareBase::isClockStateExternal()
965 if(BitManipulator::readBits(stripCSRRegisterValue_, 16, 1) == 1)
972 void FSSRFirmwareBase::setCSRRegister(uint32_t total) { stripCSRRegisterValue_ = total; }
975 void FSSRFirmwareBase::setPacketSizeStripCSR(uint32_t size)
978 __COUT__ <<
"ERROR: Maximum packet size is 31 while here you are trying to set "
979 << size <<
" packets!" << std::endl;
980 BitManipulator::insertBits(stripCSRRegisterValue_, size, 3, 5);
985 void FSSRFirmwareBase::enableChannelsStripCSR(
bool channel0,
992 BitManipulator::insertBits(stripCSRRegisterValue_,
993 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
994 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
995 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1001 void FSSRFirmwareBase::setExternalBCOClockSourceStripCSR(std::string clockSource)
1003 if(clockSource ==
"External")
1004 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 16, 1);
1005 else if(clockSource ==
"Internal")
1006 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 16, 1);
1016 void FSSRFirmwareBase::armBCOResetCSR(
void)
1018 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 19, 1);
1022 void FSSRFirmwareBase::flushBuffersStripCSR(
void)
1024 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 20, 1);
1028 void FSSRFirmwareBase::resetTriggerCounterStripCSR(std::string& buffer)
1031 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
1032 communicationFirmwareInstance_->write(
1033 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
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 );
1047 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 21, 1);
1048 communicationFirmwareInstance_->write(
1049 buffer, STRIP_CSR, stripCSRRegisterValue_,
false );
1053 void FSSRFirmwareBase::resetBCOCounterStripCSR(
void)
1055 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 22, 1);
1059 void FSSRFirmwareBase::enableTriggerStripCSR(
bool enable)
1061 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)enable, 23, 1);
1065 void FSSRFirmwareBase::sendTriggerDataStripCSR(
bool send)
1067 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 24, 1);
1071 void FSSRFirmwareBase::sendTriggerNumberStripCSR(
bool send)
1073 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 25, 1);
1077 void FSSRFirmwareBase::sendBCOStripCSR(
bool send)
1079 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)send, 26, 1);
1083 void FSSRFirmwareBase::enableStreamStripCSR(
bool enable)
1085 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)enable, 27, 1);
1089 void FSSRFirmwareBase::resetDCMStripCSR(
bool clear)
1091 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t)clear, 31, 1);
1095 uint32_t FSSRFirmwareBase::waitDCMResetStripCSR(
void)
1097 uint32_t bitToCheck = 0;
1098 BitManipulator::insertBits(bitToCheck, 1, 31, 2);
1103 void FSSRFirmwareBase::resetDAC(
void)
1105 BitManipulator::insertBits(stripResetRegisterValue_, 1, 27, 1);
1109 void FSSRFirmwareBase::resetLink(
bool channel0,
1116 stripResetRegisterValue_ = 0;
1117 BitManipulator::insertBits(stripResetRegisterValue_,
1118 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1119 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1120 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1123 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
1137 void FSSRFirmwareBase::clearErrors(
bool channel0,
1144 stripResetRegisterValue_ = 0;
1145 BitManipulator::insertBits(stripResetRegisterValue_,
1146 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1147 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1148 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1151 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
1155 void FSSRFirmwareBase::clearFIFO(
bool channel0,
1162 stripResetRegisterValue_ = 0;
1163 BitManipulator::insertBits(stripResetRegisterValue_,
1164 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1165 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1166 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1169 BitManipulator::insertBits(stripResetRegisterValue_, 1, 30, 1);
1173 void FSSRFirmwareBase::resetChip(
bool channel0,
1180 stripResetRegisterValue_ = 0;
1181 BitManipulator::insertBits(stripResetRegisterValue_,
1182 ((uint32_t)channel0) + ((uint32_t)channel1 << 1) +
1183 ((uint32_t)channel2 << 2) + ((uint32_t)channel3 << 3) +
1184 ((uint32_t)channel4 << 4) + ((uint32_t)channel5 << 5),
1187 BitManipulator::insertBits(stripResetRegisterValue_, 1, 31, 1);
1191 void FSSRFirmwareBase::setFrequencyRatio(std::string& buffer,
1197 communicationFirmwareInstance_->write(
1200 0x80500000 + (numerator - 1));
1201 communicationFirmwareInstance_->waitClear(
1206 communicationFirmwareInstance_->write(
1209 0x80520000 + (denominator - 1));
1210 communicationFirmwareInstance_->waitClear(
1211 buffer, STRIP_BCO_DCM, 0xf0000000);
1216 void FSSRFirmwareBase::BCOOffset(uint32_t offset)
1218 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, offset, 0, 4);
1222 void FSSRFirmwareBase::selectSpyFIFO(uint32_t input)
1224 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, input, 4, 3);
1228 void FSSRFirmwareBase::halt(
bool halt)
1230 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, (uint32_t)halt, 7, 1);
1234 void FSSRFirmwareBase::configureStripTriggerUnbiased(std::string& buffer)
1236 communicationFirmwareInstance_->write(
1238 STRIP_TRIG_UNBIASED,
1244 void FSSRFirmwareBase::configureTriggerInputs(std::string& buffer)
1250 communicationFirmwareInstance_->write(
1255 communicationFirmwareInstance_->write(
1260 communicationFirmwareInstance_->write(
1268 std::string FSSRFirmwareBase::resetSlaveBCO(
void)
1272 communicationFirmwareInstance_->write(
1273 buffer, (uint32_t)0xc5000000, (uint32_t)0x00000008);
void makeDACBuffer(std::string &buffer, unsigned int channel, const ROCStream &rocStream)