00001
00002
00003
00004
00005
00006
00007
00008 #include "otsdaq-components/DetectorHardware/VIPICROCDefinitions.h"
00009 #include "otsdaq-core/BitManipulator/BitManipulator.h"
00010
00011 #include "otsdaq-core/Macros/CoutMacros.h"
00012 #include <cassert>
00013 #include <iostream>
00014 #include<cstdlib>
00015
00016 using namespace ots;
00017
00018
00019
00020 VIPICROCDefinitions::VIPICROCDefinitions()
00021 {}
00022
00023
00024 VIPICROCDefinitions::~VIPICROCDefinitions (void)
00025 {}
00026
00027
00028 unsigned int VIPICROCDefinitions::getDACRegisterAddress(const std::string& registerName)
00029 {
00030 if (registerName == "PulserData" ) return 1;
00031 else if (registerName == "PulserControl") return 2;
00032 else if (registerName == "IntegratorVbn") return 3;
00033 else if (registerName == "ShaperVbp2" ) return 4;
00034 else if (registerName == "ShaperVbp1" ) return 5;
00035 else if (registerName == "BLRestorer" ) return 6;
00036 else if (registerName == "VTn" ) return 7;
00037 else if (registerName == "VTp0" ) return 8;
00038 else if (registerName == "VTp1" ) return 9;
00039 else if (registerName == "VTp2" ) return 10;
00040 else if (registerName == "VTp3" ) return 11;
00041 else if (registerName == "VTp4" ) return 12;
00042 else if (registerName == "VTp5" ) return 13;
00043 else if (registerName == "VTp6" ) return 14;
00044 else if (registerName == "VTp7" ) return 15;
00045 else if (registerName == "ActiveLines" ) return 16;
00046 else if (registerName == "SendData" ) return 19;
00047 else if (registerName == "RejectHits" ) return 20;
00048 else if (registerName == "DigContrReg" ) return 27;
00049 else if (registerName == "AqBCO" ) return 30;
00050
00051 else if (registerName == "Kill" ) return 17;
00052 else if (registerName == "Inject" ) return 18;
00053 else
00054 {
00055 std::cout << __COUT_HDR_FL__ << " Register Name not recognized!" << std::endl;
00056 assert(0);
00057 }
00058 return 0;
00059 }
00060
00061
00062 uint64_t VIPICROCDefinitions::makeDACWriteHeader(int chipId, const std::string& registerName)
00063 {
00064 return makeDACHeader(chipId, registerName, write);
00065 }
00066
00067
00068 uint64_t VIPICROCDefinitions::makeDACSetHeader(int chipId, const std::string& registerName)
00069 {
00070 return makeDACHeader(chipId, registerName, set);
00071 }
00072
00073
00074 uint64_t VIPICROCDefinitions::makeDACResetHeader(int chipId, const std::string& registerName)
00075 {
00076 return makeDACHeader(chipId, registerName, reset);
00077 }
00078
00079
00080 uint64_t VIPICROCDefinitions::makeDACReadHeader(int chipId, const std::string& registerName)
00081 {
00082 return makeDACHeader(chipId, registerName, read);
00083 }
00084
00085
00086 uint64_t VIPICROCDefinitions::makeDACHeader(int chipId, const std::string& registerName, unsigned int instruction)
00087 {
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097 uint32_t command = 0x80000000;
00098 uint32_t registerAddress = getDACRegisterAddress(registerName);
00099
00100 BitManipulator::insertBits(command,chipId,0,5);
00101
00102 BitManipulator::insertBits(command,registerAddress,5,5);
00103
00104 BitManipulator::insertBits(command,instruction,10,3);
00105
00106
00107
00108 unsigned int length = 3;
00109 if ( registerAddress < 16 || registerAddress < 27 || registerAddress < 30)
00110 length = 3;
00111 else if ( registerAddress == 17 || registerAddress == 18 )
00112 length = 4;
00113 else if ( registerAddress == 16 )
00114 length = 2;
00115 else if ( registerAddress == 19 || registerAddress == 20 )
00116 length = 1;
00117
00118 BitManipulator::insertBits(command,length,24,7);
00119
00120 return command;
00121 }
00122
00123
00124 uint64_t VIPICROCDefinitions::makeDACWriteCommand(int chipId, const std::string& registerName, unsigned int valueToWrite)
00125 {
00126 std::cout << __COUT_HDR_FL__ << "Working on Register " << registerName << " Address: " << getDACRegisterAddress(registerName) << " Value: " << valueToWrite << std::endl;
00127 uint64_t command = 0;
00128 if (registerName != "SendData" && registerName != "RejectHits")
00129 {
00130 command = makeDACWriteHeader(chipId, registerName);
00131 BitManipulator::insertBits(command,BitManipulator::reverseBits(valueToWrite,0,8),13,8);
00132 }
00133 else
00134 if (valueToWrite == 1)
00135 command = makeDACSetHeader(chipId, registerName);
00136 else
00137 command = makeDACResetHeader(chipId, registerName);
00138
00139
00140 return command;
00141 }
00142
00143
00144 uint64_t VIPICROCDefinitions::makeDACReadCommand(int chipId, const std::string& registerName)
00145 {
00146 return makeDACHeader(chipId, registerName, read);
00147 }
00148
00149
00150 std::string VIPICROCDefinitions::makeMaskWriteCommand (int chipId, const std::string& registerName, std::string valueToWrite)
00151 {
00152 std::string command = "0000000000000000000";
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185 return command;
00186 }
00187
00188
00189 uint64_t VIPICROCDefinitions::makeMaskReadCommand (int chipId, const std::string& registerName)
00190 {
00191 return 0;
00192 }
00193
00194
00195 uint64_t VIPICROCDefinitions::setSendData(int chipId)
00196 {
00197 return makeDACWriteCommand(chipId, "SendData", 1);
00198 }
00199
00200
00201 uint64_t VIPICROCDefinitions::resetSendData(int chipId)
00202 {
00203 return makeDACWriteCommand(chipId, "SendData", 0);
00204 }
00205
00206
00207 uint64_t VIPICROCDefinitions::setRejectHits(int chipId)
00208 {
00209 return makeDACWriteCommand(chipId, "RejectHits", 1);
00210 }
00211
00212
00213 uint64_t VIPICROCDefinitions::resetRejectHits(int chipId)
00214 {
00215 return makeDACWriteCommand(chipId, "RejectHits", 0);
00216 }