1 #include "otsdaq-components/DAQHardware/FSSRFirmwareBase.h"
3 #include "otsdaq-core/MessageFacility/MessageFacility.h"
4 #include "otsdaq-core/Macros/CoutMacros.h"
6 #include "otsdaq-components/DAQHardware/FSSRFirmwareDefinitions.h"
7 #include "otsdaq-core/BitManipulator/BitManipulator.h"
8 #include "otsdaq-components/DetectorHardware/FSSRROCDefinitions.h"
10 #include <sys/socket.h>
11 #include <netinet/in.h>
12 #include <arpa/inet.h>
17 #include "otsdaq-components/DAQHardware/FrontEndFirmwareBase.h"
18 #include "otsdaq-components/DAQHardware/PurdueFirmwareCore.h"
19 #include "otsdaq-components/DAQHardware/OtsUDPFirmwareCore.h"
23 const std::string FSSRFirmwareBase::PURDUE_FIRMWARE_NAME =
"PurdueFSSRFirmware";
24 const std::string FSSRFirmwareBase::OTS_FIRMWARE_NAME =
"OtsUDPFSSRFirmware";
28 FSSRFirmwareBase::FSSRFirmwareBase(
29 const std::string& communicationFirmwareType,
30 unsigned int communicationFirmwareVersion,
32 : stripCSRRegisterValue_(0)
33 , communicationFirmwareType_(communicationFirmwareType)
36 if(communicationFirmwareType == FSSRFirmwareBase::PURDUE_FIRMWARE_NAME)
38 else if(communicationFirmwareType == FSSRFirmwareBase::OTS_FIRMWARE_NAME)
42 __SS__ <<
"Unknown communication firmware type choice: " <<
43 communicationFirmwareType << std::endl;
44 __COUT_ERR__ << ss.str();
45 throw std::runtime_error(ss.str());
56 FSSRFirmwareBase::~FSSRFirmwareBase(
void)
58 delete communicationFirmwareInstance_;
59 communicationFirmwareInstance_= NULL;
63 void FSSRFirmwareBase::init(
void)
68 std::string FSSRFirmwareBase::universalRead(
char* address)
70 __COUT__ <<
"universalRead communicationFirmwareType_ " << communicationFirmwareType_ << std::endl;
71 return communicationFirmwareInstance_->read(address);
75 std::string FSSRFirmwareBase::universalWrite(
char* address,
char* data)
77 __COUT__ <<
"universalWrite communicationFirmwareType_ " << communicationFirmwareType_ << std::endl;
78 return communicationFirmwareInstance_->write(address, data);
82 uint32_t FSSRFirmwareBase::createRegisterFromValue (std::string& readBuffer, std::string& receivedValue)
84 return communicationFirmwareInstance_->createRegisterFromValue(readBuffer,receivedValue);
88 std::string FSSRFirmwareBase::configureClocks(std::string source,
double frequency)
90 std::cout << __COUT_HDR_FL__ <<
"Writing Clock configuration!" << std::endl;
95 setPacketSizeStripCSR(6);
96 setExternalBCOClockSourceStripCSR(source);
97 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
100 alignReadOut(buffer,0x3000);
102 setFrequencyFromClockState(buffer, frequency);
103 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
106 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
112 void FSSRFirmwareBase::resetDCM(std::string& buffer)
114 __COUT__ << communicationFirmwareInstance_ << std::endl;
115 resetDCMStripCSR(
true);
116 __COUT__ << communicationFirmwareInstance_ << std::endl;
118 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
120 __COUT__ << communicationFirmwareInstance_ << std::endl;
122 resetDCMStripCSR(
false);
123 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
125 communicationFirmwareInstance_->waitClear(buffer, STRIP_CSR, waitDCMResetStripCSR(),
false);
130 void FSSRFirmwareBase::alignReadOut(std::string& buffer, uint32_t value)
132 communicationFirmwareInstance_->write(buffer, STRIP_TRIM_CSR, value);
135 std::string FSSRFirmwareBase::resetDetector(
int channel)
137 std::cout << __COUT_HDR_FL__ <<
"Resetting detector!" << std::endl;
142 communicationFirmwareInstance_->write(buffer, STRIP_RESET, 0xf000003f);
143 communicationFirmwareInstance_->waitClear(buffer, STRIP_RESET, 0xf0000000);
146 communicationFirmwareInstance_->write(buffer, STRIP_RESET, 0xf000003f);
147 communicationFirmwareInstance_->waitClear(buffer, STRIP_RESET, 0xf0000000);
154 std::string FSSRFirmwareBase::enableTrigger(
void)
157 std::cout << __COUT_HDR_FL__ <<
"Enabling Trigger!!!" << std::endl;
158 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue in :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
161 sendTriggerDataStripCSR(
true);
162 sendTriggerNumberStripCSR(
true);
163 sendBCOStripCSR(
true);
164 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
166 stripTriggerCSRRegisterValue_ = 0;
168 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_CSR, stripTriggerCSRRegisterValue_,
false);
173 configureStripTriggerUnbiased(buffer);
175 configureTriggerInputs(buffer);
179 if (1 || communicationFirmwareInstance_->getVersion() == 1)
180 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_3, 0x20401000,
false);
181 else if (communicationFirmwareInstance_->getVersion() == 2)
182 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_3, 0x20301000,
false);
185 __SS__ <<
"what version is this?" << communicationFirmwareInstance_->getVersion() << std::endl;
186 __COUT__ << ss.str();
187 throw std::runtime_error(ss.str());
189 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
190 std::cout << __COUT_HDR_FL__ <<
"Done enabling Trigger!!!" << std::endl;
219 std::string FSSRFirmwareBase::resetBCO(
void)
221 std::cout << __COUT_HDR_PL__ <<
"Reset BCO!!!" << std::endl;
222 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue in :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
225 resetTriggerCounterStripCSR(buffer);
227 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
230 communicationFirmwareInstance_->write(buffer,STRIP_SC_CSR,0x903f0b95,
false);
235 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
236 std::cout << __COUT_HDR_FL__ <<
"Done reset BCO!!!" << std::endl;
242 std::string FSSRFirmwareBase::armBCOReset(
void)
244 std::cout << __COUT_HDR_FL__ << std::endl;
245 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue in :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
248 enableBCOStripCSR(
true);
249 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
250 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
251 std::cout << __COUT_HDR_FL__ <<
"Done!" << std::endl;
257 std::string FSSRFirmwareBase::startStream(
bool channel0,
bool channel1,
bool channel2,
bool channel3,
bool channel4,
bool channel5)
259 std::cout << __COUT_HDR_FL__ <<
"Start Stream!" << std::endl;
260 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue in:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
263 std::cout << __COUT_HDR_PL__ <<
" channel0 " << channel0 <<
" channel1 " << channel1 <<
" channel2 " << channel2 <<
" channel3 " << channel3 <<
" channel4 " << channel4 <<
" channel5 " << channel5 << std::endl;
265 enableChannelsStripCSR(channel0, channel1, channel2, channel3, channel4, channel5);
271 enableStreamStripCSR(
true);
272 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
274 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
275 std::cout << __COUT_HDR_PL__ <<
"Done start Stream!" << std::endl;
281 std::string FSSRFirmwareBase::stopStream(
void)
284 enableChannelsStripCSR(
false,
false,
false,
false,
false,
false);
285 enableStreamStripCSR(
false);
286 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
293 const ROCDACs& rocDACs = rocStream.getROCDACs();
294 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it != rocDACs.getDACList().end(); it++)
297 uint64_t data = FSSRROCDefinitions::makeDACWriteCommand(
298 rocStream.getFEWROCAddress(), it->first, it->second.second);
299 sequence.pushBack(ChannelFIFOAddress[channel], data);
300 sequence.pushBack(ChannelFIFOAddress[channel],
301 BitManipulator::insertBits(data, (uint64_t) 0x48, 56, 8));
303 sequence.pushBack(ChannelFIFOAddress[channel],
304 BitManipulator::insertBits(data, (uint64_t) 1, 60, 1));
306 sequence.pushBack(ChannelFIFOAddress[channel],
307 BitManipulator::insertBits(data, (uint64_t) 0, 60, 1));
309 sequence.pushBack(ChannelFIFOAddress[channel],
310 BitManipulator::insertBits(data, (uint64_t) 0, 62, 1));
311 sequence.pushBack(ChannelFIFOAddress[channel],
312 BitManipulator::insertBits(data, (uint64_t) 0x40, 56, 8));
319 unsigned int channel,
const ROCStream& rocStream)
321 const ROCDACs& rocDACs = rocStream.getROCDACs();
322 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it
323 != rocDACs.getDACList().end(); it++)
340 uint32_t data = FSSRROCDefinitions::makeDACWriteHeader(
341 rocStream.getFEWROCAddress(), it->first);
343 BitManipulator::insertBits(data, 1, 16 + channel, 1);
344 sequence.pushBack(ChannelFIFOAddress[channel], it->second.second);
345 std::cout << __COUT_HDR_FL__ <<
"Register: " << it->first <<
" value: "
346 << it->second.second << std::hex <<
" -> Data: " << data << std::dec
348 sequence.pushBack(STRIP_SC_CSR, data);
353 void FSSRFirmwareBase::makeDACBuffer(std::string& buffer,
unsigned int channel,
const ROCStream& rocStream)
355 std::cout << __COUT_HDR_FL__ <<
"Channel: " << channel << std::endl;
356 std::cout << __COUT_HDR_FL__ <<
"BufferINsize: " << buffer.size() << std::endl;
357 const ROCDACs& rocDACs = rocStream.getROCDACs();
403 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it != rocDACs.getDACList().end(); it++)
405 std::string bufferElement;
406 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
407 uint32_t registerHeader = 0;
409 if (it->first !=
"RejectHits" && it->first !=
"SendData")
411 communicationFirmwareInstance_->write(bufferElement, ChannelFIFOAddress[channel], it->second.second,
false);
412 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(rocStream.getFEWROCAddress(), it->first);
414 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
418 if (it->second.second == 1 || it->second.second == 2)
420 registerHeader = FSSRROCDefinitions::makeDACSetHeader(rocStream.getFEWROCAddress(), it->first);
422 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
424 else if (it->second.second == 0 || it->second.second == 5)
426 registerHeader = FSSRROCDefinitions::makeDACResetHeader(rocStream.getFEWROCAddress(), it->first);
428 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
431 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it->first
432 <<
" doesn't have a value I expect -> value = "
433 << it->second.second << std::endl;
438 communicationFirmwareInstance_->write(bufferElement, STRIP_SC_CSR, registerHeader,
false);
439 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
442 buffer += bufferElement;
445 std::cout << __COUT_HDR_FL__ <<
"BufferOUTsize: " << buffer.size() << std::endl;
449 void FSSRFirmwareBase::makeDACBuffer(std::vector<std::string>& buffer,
unsigned int channel,
const ROCStream& rocStream)
452 std::cout << __COUT_HDR_FL__ <<
"\tMaking DAC Buffer" << std::endl;
455 unsigned int singleVectorCount = 0;
457 std::string alternateBuffer;
459 std::cout << __COUT_HDR_FL__ <<
"Channel: " << channel << std::endl;
460 const ROCDACs& rocDACs = rocStream.getROCDACs();
462 std::string bufferElement;
465 for (
const std::pair<std::string, std::pair<unsigned int, unsigned int> >& it: rocDACs.getDACList())
471 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
472 uint32_t registerHeader = 0;
475 if (it.first !=
"RejectHits" && it.first !=
"SendData")
478 communicationFirmwareInstance_->write(bufferElement, ChannelFIFOAddress[channel], it.second.second,
false);
479 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(rocStream.getFEWROCAddress(), it.first);
481 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
486 if (it.second.second == 1 || it.second.second == 2)
488 registerHeader = FSSRROCDefinitions::makeDACSetHeader(rocStream.getFEWROCAddress(), it.first);
490 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
492 else if (it.second.second == 0 || it.second.second == 5)
494 registerHeader = FSSRROCDefinitions::makeDACResetHeader(rocStream.getFEWROCAddress(), it.first);
496 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
499 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it.first
500 <<
" doesn't have a value I expect -> value = "
501 << it.second.second << std::endl;
505 communicationFirmwareInstance_->write(bufferElement, STRIP_SC_CSR, registerHeader,
false);
506 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
513 if (limitCount == STIB_DAC_WRITE_MAX)
515 std::cout << __COUT_HDR_FL__ <<
"\tBuffer length:" << bufferElement.size() << std::endl;
516 buffer.push_back(bufferElement);
518 bufferElement.clear();
520 else if (singleVectorCount == rocDACs.getDACList().size())
522 buffer.push_back(bufferElement);
528 std::cout << __COUT_HDR_FL__ <<
"\tDone making DAC Buffer" << std::endl;
533 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
unsigned int channel,
536 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
537 makeMaskBuffer(buffer, channel, rocStream,
"Kill");
542 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
unsigned int channel,
const ROCStream& rocStream,
const std::string& registerName)
544 int chipId = rocStream.getFEWROCAddress();
545 const std::string& mask = rocStream.getROCMask();
546 std::cout << __COUT_HDR_FL__ <<
"\tMaking mask! Length = " << mask.length() << std::endl;
550 unsigned int data[4] = { 0, 0, 0, 0 };
554 for (
unsigned int d = 0; d < 4; d++)
557 for (
unsigned int m = 0; m < 8 * 4; m++)
559 val = mask[(8 * 4 * d) + m];
562 data[d] |= (
unsigned int) atoi(&val) << (8 * 4 - 1 - m);
572 unsigned char len = 4;
573 unsigned char addr = 17;
574 unsigned char bitMask = 1 << channel;
575 unsigned char inst = WRITE;
577 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
579 for (i = 0; i < 4; i++)
581 communicationFirmwareInstance_->write(buffer, STRIP_SCI + 4 * (4 - i - 1), data[i],
false);
583 w = 0x80000000 | (len << 24) | (bitMask << 16) | (inst << 10) | (addr << 5) | chipId;
585 communicationFirmwareInstance_->write(buffer, STRIP_SC_CSR, w,
false);
587 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
592 unsigned int channel,
const ROCStream& rocStream)
594 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
595 makeMaskSequence(sequence, channel, rocStream,
"Kill");
601 unsigned int channel,
const ROCStream& rocStream)
603 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
604 makeMaskSequence(sequence, channel, rocStream,
"Kill");
610 unsigned int channel,
const ROCStream& rocStream,
611 const std::string& registerName)
613 int chipId = rocStream.getFEWROCAddress();
614 std::string mask = rocStream.getROCMask();
615 std::cout << __COUT_HDR_FL__ <<
"Mask length: " << mask.length() << std::endl;
617 uint64_t uInt64Data = 0;
618 std::string stringData =
"";
636 BitManipulator::insertBits(uInt64Data, 0x1, 56, 8);
637 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
640 BitManipulator::insertBits(uInt64Data, 0x2, 56, 8);
641 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
647 BitManipulator::insertBits(uInt64Data, 0x40, 16, 8);
648 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
649 BitManipulator::insertBits(uInt64Data, 0xc0, 16, 8);
650 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
652 stringData = FSSRROCDefinitions::makeMaskWriteCommand(chipId,
656 for (
unsigned int s = 0; s < stringData.length(); s++)
657 for (
int b = 8 - 1; b >= 0 && (s * 8 + 8 - b < 13 + 128); b--)
660 data = 0x40 | (((stringData.data()[s] >> b) & 1) << 5);
661 BitManipulator::insertBits(uInt64Data, (uint64_t) data, 16, 8);
662 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
664 BitManipulator::insertBits(uInt64Data, (uint64_t) data, 16, 8);
665 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
669 BitManipulator::insertBits(uInt64Data, 0x0, 16, 8);
670 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
671 BitManipulator::insertBits(uInt64Data, 0x80, 16, 8);
672 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
675 BitManipulator::insertBits(uInt64Data, 0x0, 56, 8);
676 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
679 BitManipulator::insertBits(uInt64Data, 0x80, 56, 8);
680 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
686 unsigned int channel,
const ROCStream& rocStream,
687 const std::string& registerName)
691 std::string FSSRFirmwareBase::readCSRRegister()
694 std::cout << __COUT_HDR_FL__ <<
"FSSR readCSRRegister" << std::endl;
695 communicationFirmwareInstance_->read(buffer,STRIP_CSR);
700 std::string FSSRFirmwareBase::readSCCSRRegister()
703 std::cout << __COUT_HDR_FL__ <<
"FSSR readCSRRegister" << std::endl;
704 communicationFirmwareInstance_->read(buffer,STRIP_SC_CSR);
709 void FSSRFirmwareBase::setFrequencyFromClockState(std::string& buffer,
double frequency)
711 std::cout << __COUT_HDR_FL__ <<
"Setting up clock frequency!!!" << std::endl;
716 double realClockFrequency;
718 if (BitManipulator::readBits(stripCSRRegisterValue_, 17, 1) == 1)
723 if (isClockStateExternal())
725 realClockFrequency = EXTERNAL_CLOCK_FREQUENCY / quotient;
729 realClockFrequency = INTERNAL_CLOCK_FREQUENCY / quotient;
732 double factor = frequency / realClockFrequency;
738 numerator = factor * 100;
745 int rest = denominator;
768 while (denominator >= 32 || numerator >= 32);
772 std::cout << __COUT_HDR_FL__ <<
"Numerator: " << numerator << std::endl;
773 std::cout << __COUT_HDR_FL__ <<
"Denominator: " << denominator << std::endl;
774 setFrequencyRatio(buffer, numerator, denominator);
775 std::cout << __COUT_HDR_FL__ <<
"Done with clock frequency setup!!!" << std::endl;
778 bool FSSRFirmwareBase::isClockStateExternal()
780 if (BitManipulator::readBits(stripCSRRegisterValue_, 16, 1) == 1)
787 void FSSRFirmwareBase::setCSRRegister(uint32_t total)
789 stripCSRRegisterValue_ = total;
793 void FSSRFirmwareBase::setPacketSizeStripCSR(uint32_t size)
796 std::cout << __COUT_HDR_FL__
797 <<
"ERROR: Maximum packet size is 31 while here you are trying to set "
798 << size <<
" packets!" << std::endl;
799 BitManipulator::insertBits(stripCSRRegisterValue_, size, 3, 5);
804 void FSSRFirmwareBase::enableChannelsStripCSR(
bool channel0,
bool channel1,
805 bool channel2,
bool channel3,
bool channel4,
bool channel5)
807 BitManipulator::insertBits(stripCSRRegisterValue_, ((uint32_t) channel0)
808 + ((uint32_t) channel1 << 1) + ((uint32_t) channel2 << 2)
809 + ((uint32_t) channel3 << 3) + ((uint32_t) channel4 << 4)
810 + ((uint32_t) channel5 << 5), 8, 6);
814 void FSSRFirmwareBase::setExternalBCOClockSourceStripCSR(std::string clockSource)
816 if (clockSource ==
"External")
817 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 16, 1);
818 else if (clockSource ==
"Internal")
819 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 16, 1);
823 void FSSRFirmwareBase::setHaltStripCSR(
bool set)
825 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) set, 17, 1);
829 void FSSRFirmwareBase::enableBCOStripCSR(
bool enable)
831 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) enable, 19, 1);
835 void FSSRFirmwareBase::flushBuffersStripCSR(
void)
837 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 20, 1);
841 void FSSRFirmwareBase::resetTriggerCounterStripCSR(std::string& buffer)
844 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
845 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
852 void FSSRFirmwareBase::resetBCOCounterStripCSR(
void)
854 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 22, 1);
858 void FSSRFirmwareBase::enableTriggerStripCSR(
bool enable)
860 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) enable, 23, 1);
864 void FSSRFirmwareBase::sendTriggerDataStripCSR(
bool send)
866 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 24, 1);
870 void FSSRFirmwareBase::sendTriggerNumberStripCSR(
bool send)
872 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 25, 1);
876 void FSSRFirmwareBase::sendBCOStripCSR(
bool send)
878 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 26, 1);
882 void FSSRFirmwareBase::enableStreamStripCSR(
bool enable)
884 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) enable, 27, 1);
888 void FSSRFirmwareBase::resetDCMStripCSR(
bool clear)
890 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) clear, 31, 1);
894 uint32_t FSSRFirmwareBase::waitDCMResetStripCSR(
void)
896 uint32_t bitToCheck = 0;
897 BitManipulator::insertBits(bitToCheck, 1, 31, 2);
902 void FSSRFirmwareBase::resetDAC(
void)
904 BitManipulator::insertBits(stripResetRegisterValue_, 1, 27, 1);
908 void FSSRFirmwareBase::resetLink(
bool channel0,
bool channel1,
bool channel2,
909 bool channel3,
bool channel4,
bool channel5)
911 stripResetRegisterValue_ = 0;
912 BitManipulator::insertBits(stripResetRegisterValue_,
913 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
914 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
915 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
917 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
931 void FSSRFirmwareBase::clearErrors(
bool channel0,
bool channel1,
bool channel2,
932 bool channel3,
bool channel4,
bool channel5)
934 stripResetRegisterValue_ = 0;
935 BitManipulator::insertBits(stripResetRegisterValue_,
936 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
937 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
938 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
940 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
944 void FSSRFirmwareBase::clearFIFO(
bool channel0,
bool channel1,
bool channel2,
945 bool channel3,
bool channel4,
bool channel5)
947 stripResetRegisterValue_ = 0;
948 BitManipulator::insertBits(stripResetRegisterValue_,
949 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
950 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
951 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
953 BitManipulator::insertBits(stripResetRegisterValue_, 1, 30, 1);
957 void FSSRFirmwareBase::resetChip(
bool channel0,
bool channel1,
bool channel2,
958 bool channel3,
bool channel4,
bool channel5)
960 stripResetRegisterValue_ = 0;
961 BitManipulator::insertBits(stripResetRegisterValue_,
962 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
963 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
964 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
966 BitManipulator::insertBits(stripResetRegisterValue_, 1, 31, 1);
970 void FSSRFirmwareBase::setFrequencyRatio(std::string& buffer,
int numerator,
int denominator)
973 communicationFirmwareInstance_->write(buffer, STRIP_BCO_DCM, 0x80500000 + (numerator - 1));
974 communicationFirmwareInstance_->waitClear(buffer, STRIP_BCO_DCM, 0xf0000000);
976 communicationFirmwareInstance_->write(buffer, STRIP_BCO_DCM, 0x80520000 + (denominator - 1));
977 communicationFirmwareInstance_->waitClear(buffer, STRIP_BCO_DCM, 0xf0000000);
981 void FSSRFirmwareBase::BCOOffset(uint32_t offset)
983 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, offset, 0, 4);
987 void FSSRFirmwareBase::selectSpyFIFO(uint32_t input)
989 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, input, 4, 3);
993 void FSSRFirmwareBase::halt(
bool halt)
995 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, (uint32_t) halt, 7, 1);
999 void FSSRFirmwareBase::configureStripTriggerUnbiased(std::string& buffer)
1001 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_UNBIASED, 0x002805c,
false);
1005 void FSSRFirmwareBase::configureTriggerInputs(std::string& buffer)
1009 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_0, 0x0,
false);
1010 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_1, 0x0,
false);
1011 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_2, 0x0,
false);
1015 std::string FSSRFirmwareBase::resetSlaveBCO(
void)
1019 communicationFirmwareInstance_->write(buffer, (uint32_t)0xc5000000, (uint32_t)0x00000008);