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();
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)
95 setPacketSizeStripCSR(6);
96 setExternalBCOClockSourceStripCSR(source);
97 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
102 setFrequencyFromClockState(buffer, frequency);
103 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
112 void FSSRFirmwareBase::resetDCM(std::string& buffer)
115 resetDCMStripCSR(
true);
116 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
118 resetDCMStripCSR(
false);
119 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
127 void FSSRFirmwareBase::alignReadOut(std::string& buffer,
unsigned int sensor,
unsigned int chip)
134 communicationFirmwareInstance_->write(buffer, STRIP_TRIM_CSR, (0x9<<28)+((chip&0xf)<<3)+(sensor&0x7));
137 std::string FSSRFirmwareBase::resetDetector(
int channel)
162 communicationFirmwareInstance_->write(buffer, STRIP_RESET, 0xf000003f);
167 communicationFirmwareInstance_->write(buffer, STRIP_RESET, 0xf000003f);
176 std::string FSSRFirmwareBase::enableTrigger(
void)
183 sendTriggerDataStripCSR (
false);
184 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
185 resetTriggerCounterStripCSR(buffer);
186 sendTriggerDataStripCSR (
true);
187 sendTriggerNumberStripCSR(
true);
188 sendBCOStripCSR (
true);
189 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
191 stripTriggerCSRRegisterValue_ = 0;
193 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_CSR, stripTriggerCSRRegisterValue_,
false);
198 configureStripTriggerUnbiased(buffer);
200 configureTriggerInputs(buffer);
205 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_3, 0x20401000,
false);
244 std::string FSSRFirmwareBase::resetBCO(
void)
246 std::cout << __COUT_HDR_PL__ <<
"Reset BCO!!!" << std::endl;
247 std::cout << __COUT_HDR_FL__ <<
"stripCSRRegisterValue in :" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
287 communicationFirmwareInstance_->write(buffer, STRIP_SC_CSR, 0x903f0b95,
false);
292 std::cout << __COUT_HDR_PL__ <<
"stripCSRRegisterValue out:" << std::hex << stripCSRRegisterValue_ << std::dec << std::endl;
293 std::cout << __COUT_HDR_FL__ <<
"Done reset BCO!!!" << std::endl;
299 std::string FSSRFirmwareBase::armBCOReset(
void)
303 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
308 std::string FSSRFirmwareBase::startStream(
bool channel0,
bool channel1,
bool channel2,
bool channel3,
bool channel4,
bool channel5)
316 enableChannelsStripCSR(channel0, channel1, channel2, channel3, channel4, channel5);
322 enableStreamStripCSR(
true);
323 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
332 std::string FSSRFirmwareBase::stopStream(
void)
335 enableStreamStripCSR(
false);
336 enableChannelsStripCSR(
false,
false,
false,
false,
false,
false);
337 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_);
344 const ROCDACs& rocDACs = rocStream.getROCDACs();
345 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it != rocDACs.getDACList().end(); it++)
348 uint64_t data = FSSRROCDefinitions::makeDACWriteCommand(
349 rocStream.getFEWROCAddress(), it->first, it->second.second);
350 sequence.pushBack(ChannelFIFOAddress[channel], data);
351 sequence.pushBack(ChannelFIFOAddress[channel],
352 BitManipulator::insertBits(data, (uint64_t) 0x48, 56, 8));
354 sequence.pushBack(ChannelFIFOAddress[channel],
355 BitManipulator::insertBits(data, (uint64_t) 1, 60, 1));
357 sequence.pushBack(ChannelFIFOAddress[channel],
358 BitManipulator::insertBits(data, (uint64_t) 0, 60, 1));
360 sequence.pushBack(ChannelFIFOAddress[channel],
361 BitManipulator::insertBits(data, (uint64_t) 0, 62, 1));
362 sequence.pushBack(ChannelFIFOAddress[channel],
363 BitManipulator::insertBits(data, (uint64_t) 0x40, 56, 8));
370 unsigned int channel,
const ROCStream& rocStream)
372 const ROCDACs& rocDACs = rocStream.getROCDACs();
373 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it
374 != rocDACs.getDACList().end(); it++)
391 uint32_t data = FSSRROCDefinitions::makeDACWriteHeader(
392 rocStream.getFEWROCAddress(), it->first);
394 BitManipulator::insertBits(data, 1, 16 + channel, 1);
395 sequence.pushBack(ChannelFIFOAddress[channel], it->second.second);
396 std::cout << __COUT_HDR_FL__ <<
"Register: " << it->first <<
" value: "
397 << it->second.second << std::hex <<
" -> Data: " << data << std::dec
399 sequence.pushBack(STRIP_SC_CSR, data);
404 void FSSRFirmwareBase::makeDACBuffer(std::string& buffer,
unsigned int channel,
const ROCStream& rocStream)
406 std::cout << __COUT_HDR_FL__ <<
"Channel: " << channel << std::endl;
407 std::cout << __COUT_HDR_FL__ <<
"BufferINsize: " << buffer.size() << std::endl;
408 const ROCDACs& rocDACs = rocStream.getROCDACs();
454 for (DACList::const_iterator it = rocDACs.getDACList().begin(); it != rocDACs.getDACList().end(); it++)
456 std::string bufferElement;
457 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
458 uint32_t registerHeader = 0;
460 if (it->first !=
"RejectHits" && it->first !=
"SendData")
462 communicationFirmwareInstance_->write(bufferElement, ChannelFIFOAddress[channel], it->second.second,
false);
463 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(rocStream.getFEWROCAddress(), it->first);
465 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
469 if (it->second.second == 1 || it->second.second == 2)
471 registerHeader = FSSRROCDefinitions::makeDACSetHeader(rocStream.getFEWROCAddress(), it->first);
473 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
475 else if (it->second.second == 0 || it->second.second == 5)
477 registerHeader = FSSRROCDefinitions::makeDACResetHeader(rocStream.getFEWROCAddress(), it->first);
479 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
482 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it->first
483 <<
" doesn't have a value I expect -> value = "
484 << it->second.second << std::endl;
489 communicationFirmwareInstance_->write(bufferElement, STRIP_SC_CSR, registerHeader,
false);
490 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
493 buffer += bufferElement;
496 std::cout << __COUT_HDR_FL__ <<
"BufferOUTsize: " << buffer.size() << std::endl;
500 void FSSRFirmwareBase::makeDACBuffer(std::vector<std::string>& buffer,
unsigned int channel,
const ROCStream& rocStream)
506 unsigned int singleVectorCount = 0;
508 std::string alternateBuffer;
511 const ROCDACs& rocDACs = rocStream.getROCDACs();
513 std::string bufferElement;
516 for (
const std::pair<std::string, std::pair<unsigned int, unsigned int> >& it: rocDACs.getDACList())
522 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
523 uint32_t registerHeader = 0;
526 if (it.first !=
"RejectHits" && it.first !=
"SendData")
529 communicationFirmwareInstance_->write(bufferElement, ChannelFIFOAddress[channel], it.second.second,
false);
530 registerHeader = FSSRROCDefinitions::makeDACWriteHeader(rocStream.getFEWROCAddress(), it.first);
532 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
537 if (it.second.second == 1 || it.second.second == 2)
539 registerHeader = FSSRROCDefinitions::makeDACSetHeader(rocStream.getFEWROCAddress(), it.first);
541 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
543 else if (it.second.second == 0 || it.second.second == 5)
545 registerHeader = FSSRROCDefinitions::makeDACResetHeader(rocStream.getFEWROCAddress(), it.first);
547 BitManipulator::insertBits(registerHeader, 1, 16 + channel, 1);
550 std::cout << __COUT_HDR_FL__ <<
"Register value for : " << it.first
551 <<
" doesn't have a value I expect -> value = "
552 << it.second.second << std::endl;
556 communicationFirmwareInstance_->write(bufferElement, STRIP_SC_CSR, registerHeader,
false);
557 communicationFirmwareInstance_->waitClear(bufferElement, STRIP_SC_CSR, 0x80000000,
false);
564 if (limitCount == STIB_DAC_WRITE_MAX)
566 std::cout << __COUT_HDR_FL__ <<
"\tBuffer length:" << bufferElement.size() << std::endl;
567 buffer.push_back(bufferElement);
569 bufferElement.clear();
571 else if (singleVectorCount == rocDACs.getDACList().size())
573 buffer.push_back(bufferElement);
584 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
unsigned int channel,
588 makeMaskBuffer(buffer, channel, rocStream,
"Kill");
593 void FSSRFirmwareBase::makeMaskBuffer(std::string& buffer,
unsigned int channel,
const ROCStream& rocStream,
const std::string& registerName)
595 int chipId = rocStream.getFEWROCAddress();
596 const std::string& mask = rocStream.getROCMask();
601 unsigned int data[4] = { 0, 0, 0, 0 };
605 for (
unsigned int d = 0; d < 4; d++)
608 for (
unsigned int m = 0; m < 8 * 4; m++)
610 val = mask[(8 * 4 * d) + m];
613 data[d] |= (
unsigned int) atoi(&val) << (8 * 4 - 1 - m);
623 unsigned char len = 4;
624 unsigned char addr = 17;
625 unsigned char bitMask = 1 << channel;
626 unsigned char inst = WRITE;
628 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
630 for (i = 0; i < 4; i++)
632 communicationFirmwareInstance_->write(buffer, STRIP_SCI + 4 * (4 - i - 1), data[i],
false);
634 w = 0x80000000 | (len << 24) | (bitMask << 16) | (inst << 10) | (addr << 5) | chipId;
636 communicationFirmwareInstance_->write(buffer, STRIP_SC_CSR, w,
false);
638 communicationFirmwareInstance_->waitClear(buffer, STRIP_SC_CSR, 0x80000000,
false);
643 unsigned int channel,
const ROCStream& rocStream)
645 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
646 makeMaskSequence(sequence, channel, rocStream,
"Kill");
652 unsigned int channel,
const ROCStream& rocStream)
654 std::cout << __COUT_HDR_FL__ <<
"Making mask! " << std::endl;
655 makeMaskSequence(sequence, channel, rocStream,
"Kill");
661 unsigned int channel,
const ROCStream& rocStream,
662 const std::string& registerName)
664 int chipId = rocStream.getFEWROCAddress();
665 std::string mask = rocStream.getROCMask();
666 std::cout << __COUT_HDR_FL__ <<
"Mask length: " << mask.length() << std::endl;
668 uint64_t uInt64Data = 0;
669 std::string stringData =
"";
687 BitManipulator::insertBits(uInt64Data, 0x1, 56, 8);
688 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
691 BitManipulator::insertBits(uInt64Data, 0x2, 56, 8);
692 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
698 BitManipulator::insertBits(uInt64Data, 0x40, 16, 8);
699 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
700 BitManipulator::insertBits(uInt64Data, 0xc0, 16, 8);
701 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
703 stringData = FSSRROCDefinitions::makeMaskWriteCommand(chipId,
707 for (
unsigned int s = 0; s < stringData.length(); s++)
708 for (
int b = 8 - 1; b >= 0 && (s * 8 + 8 - b < 13 + 128); b--)
711 data = 0x40 | (((stringData.data()[s] >> b) & 1) << 5);
712 BitManipulator::insertBits(uInt64Data, (uint64_t) data, 16, 8);
713 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
715 BitManipulator::insertBits(uInt64Data, (uint64_t) data, 16, 8);
716 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
720 BitManipulator::insertBits(uInt64Data, 0x0, 16, 8);
721 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
722 BitManipulator::insertBits(uInt64Data, 0x80, 16, 8);
723 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
726 BitManipulator::insertBits(uInt64Data, 0x0, 56, 8);
727 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
730 BitManipulator::insertBits(uInt64Data, 0x80, 56, 8);
731 sequence.pushBack(ChannelFIFOAddress[channel], uInt64Data);
737 unsigned int channel,
const ROCStream& rocStream,
738 const std::string& registerName)
742 std::string FSSRFirmwareBase::readCSRRegister()
746 communicationFirmwareInstance_->read(buffer,STRIP_CSR);
751 std::string FSSRFirmwareBase::readSCCSRRegister()
754 std::cout << __COUT_HDR_FL__ <<
"FSSR readCSRRegister" << std::endl;
755 communicationFirmwareInstance_->read(buffer,STRIP_SC_CSR);
760 void FSSRFirmwareBase::setFrequencyFromClockState(std::string& buffer,
double frequency)
767 double realClockFrequency;
769 if (BitManipulator::readBits(stripCSRRegisterValue_, 17, 1) == 1)
774 if (isClockStateExternal())
776 realClockFrequency = EXTERNAL_CLOCK_FREQUENCY / quotient;
780 realClockFrequency = INTERNAL_CLOCK_FREQUENCY / quotient;
783 double factor = frequency / realClockFrequency;
789 numerator = factor * 100;
796 int rest = denominator;
819 while (denominator >= 32 || numerator >= 32);
825 setFrequencyRatio(buffer, numerator, denominator);
829 bool FSSRFirmwareBase::isClockStateExternal()
831 if (BitManipulator::readBits(stripCSRRegisterValue_, 16, 1) == 1)
838 void FSSRFirmwareBase::setCSRRegister(uint32_t total)
840 stripCSRRegisterValue_ = total;
844 void FSSRFirmwareBase::setPacketSizeStripCSR(uint32_t size)
847 std::cout << __COUT_HDR_FL__
848 <<
"ERROR: Maximum packet size is 31 while here you are trying to set "
849 << size <<
" packets!" << std::endl;
850 BitManipulator::insertBits(stripCSRRegisterValue_, size, 3, 5);
855 void FSSRFirmwareBase::enableChannelsStripCSR(
bool channel0,
bool channel1,
856 bool channel2,
bool channel3,
bool channel4,
bool channel5)
858 BitManipulator::insertBits(stripCSRRegisterValue_, ((uint32_t) channel0)
859 + ((uint32_t) channel1 << 1) + ((uint32_t) channel2 << 2)
860 + ((uint32_t) channel3 << 3) + ((uint32_t) channel4 << 4)
861 + ((uint32_t) channel5 << 5), 8, 6);
865 void FSSRFirmwareBase::setExternalBCOClockSourceStripCSR(std::string clockSource)
867 if (clockSource ==
"External")
868 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 16, 1);
869 else if (clockSource ==
"Internal")
870 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 16, 1);
880 void FSSRFirmwareBase::armBCOResetCSR(
void)
882 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 19, 1);
886 void FSSRFirmwareBase::flushBuffersStripCSR(
void)
888 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 20, 1);
892 void FSSRFirmwareBase::resetTriggerCounterStripCSR(std::string& buffer)
895 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
896 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
897 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
898 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
899 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
900 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
901 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
902 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
903 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 21, 1);
904 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
906 BitManipulator::insertBits(stripCSRRegisterValue_, 0, 21, 1);
907 communicationFirmwareInstance_->write(buffer, STRIP_CSR, stripCSRRegisterValue_,
false);
911 void FSSRFirmwareBase::resetBCOCounterStripCSR(
void)
913 BitManipulator::insertBits(stripCSRRegisterValue_, 1, 22, 1);
917 void FSSRFirmwareBase::enableTriggerStripCSR(
bool enable)
919 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) enable, 23, 1);
923 void FSSRFirmwareBase::sendTriggerDataStripCSR(
bool send)
925 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 24, 1);
929 void FSSRFirmwareBase::sendTriggerNumberStripCSR(
bool send)
931 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 25, 1);
935 void FSSRFirmwareBase::sendBCOStripCSR(
bool send)
937 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) send, 26, 1);
941 void FSSRFirmwareBase::enableStreamStripCSR(
bool enable)
943 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) enable, 27, 1);
947 void FSSRFirmwareBase::resetDCMStripCSR(
bool clear)
949 BitManipulator::insertBits(stripCSRRegisterValue_, (uint32_t) clear, 31, 1);
953 uint32_t FSSRFirmwareBase::waitDCMResetStripCSR(
void)
955 uint32_t bitToCheck = 0;
956 BitManipulator::insertBits(bitToCheck, 1, 31, 2);
961 void FSSRFirmwareBase::resetDAC(
void)
963 BitManipulator::insertBits(stripResetRegisterValue_, 1, 27, 1);
967 void FSSRFirmwareBase::resetLink(
bool channel0,
bool channel1,
bool channel2,
968 bool channel3,
bool channel4,
bool channel5)
970 stripResetRegisterValue_ = 0;
971 BitManipulator::insertBits(stripResetRegisterValue_,
972 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
973 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
974 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
976 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
990 void FSSRFirmwareBase::clearErrors(
bool channel0,
bool channel1,
bool channel2,
991 bool channel3,
bool channel4,
bool channel5)
993 stripResetRegisterValue_ = 0;
994 BitManipulator::insertBits(stripResetRegisterValue_,
995 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
996 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
997 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
999 BitManipulator::insertBits(stripResetRegisterValue_, 1, 29, 1);
1003 void FSSRFirmwareBase::clearFIFO(
bool channel0,
bool channel1,
bool channel2,
1004 bool channel3,
bool channel4,
bool channel5)
1006 stripResetRegisterValue_ = 0;
1007 BitManipulator::insertBits(stripResetRegisterValue_,
1008 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
1009 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
1010 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
1012 BitManipulator::insertBits(stripResetRegisterValue_, 1, 30, 1);
1016 void FSSRFirmwareBase::resetChip(
bool channel0,
bool channel1,
bool channel2,
1017 bool channel3,
bool channel4,
bool channel5)
1019 stripResetRegisterValue_ = 0;
1020 BitManipulator::insertBits(stripResetRegisterValue_,
1021 ((uint32_t) channel0) + ((uint32_t) channel1 << 1)
1022 + ((uint32_t) channel2 << 2) + ((uint32_t) channel3 << 3)
1023 + ((uint32_t) channel4 << 4) + ((uint32_t) channel5 << 5),
1025 BitManipulator::insertBits(stripResetRegisterValue_, 1, 31, 1);
1029 void FSSRFirmwareBase::setFrequencyRatio(std::string& buffer,
int numerator,
int denominator)
1032 communicationFirmwareInstance_->write(buffer, STRIP_BCO_DCM, 0x80500000 + (numerator - 1));
1033 communicationFirmwareInstance_->waitClear(buffer, STRIP_BCO_DCM, 0xf0000000);
1035 communicationFirmwareInstance_->write(buffer, STRIP_BCO_DCM, 0x80520000 + (denominator - 1));
1036 communicationFirmwareInstance_->waitClear(buffer, STRIP_BCO_DCM, 0xf0000000);
1040 void FSSRFirmwareBase::BCOOffset(uint32_t offset)
1042 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, offset, 0, 4);
1046 void FSSRFirmwareBase::selectSpyFIFO(uint32_t input)
1048 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, input, 4, 3);
1052 void FSSRFirmwareBase::halt(
bool halt)
1054 BitManipulator::insertBits(stripTriggerCSRRegisterValue_, (uint32_t) halt, 7, 1);
1058 void FSSRFirmwareBase::configureStripTriggerUnbiased(std::string& buffer)
1060 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_UNBIASED, 0x002805c,
false);
1064 void FSSRFirmwareBase::configureTriggerInputs(std::string& buffer)
1068 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_0, 0x0,
false);
1069 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_1, 0x0,
false);
1070 communicationFirmwareInstance_->write(buffer, STRIP_TRIG_INPUT_2, 0x0,
false);
1074 std::string FSSRFirmwareBase::resetSlaveBCO(
void)
1078 communicationFirmwareInstance_->write(buffer, (uint32_t)0xc5000000, (uint32_t)0x00000008);