Functions | |
dyn_int | fwUkl1_parseReadRegisterSections (const dyn_char &dcData, unsigned numSections, unsigned sectionGap, unsigned startBit, unsigned length, bool fpga, dyn_string &exceptionInfo) |
int | fwUkl1_parseReadRegister (dyn_char dcData, unsigned startBit, unsigned length, bool fpga, dyn_string &exceptionInfo) |
string | fwUkl1_convertMacToHex (const string &macAddress, dyn_string &exceptionInfo) |
string | fwUkl1_convertByteToMac (const dyn_char &macAddress, dyn_string &exceptionInfo) |
string | fwUkl1_convertIpToHex (const string &ipAddress, dyn_string &exceptionInfo) |
string | fwUkl1_convertByteToIp (const dyn_char &ipAddress, dyn_string &exceptionInfo) |
void | fwUkl1_convert32To16BitWords (dyn_char &dcData, dyn_string &exceptionInfo) |
string | fwUkl1_convertByteToHexLittleEndian (const dyn_char &dcData, dyn_string &exceptionInfo) |
void | fwUkl1_padString (string &sData, unsigned numBytes) |
dyn_dyn_string | fwUkl1_parseBroadcastData (const dyn_string &origData, dyn_string &exceptionInfo) |
void | fwUkl1_parseBeFpgaWriteRegisters (string ukl1Name, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseBeFpgaReadRegisters (string ukl1Name, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_parseFeFpgaWriteRegisters (string ukl1Name, unsigned feFpga, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseFeFpgaReadRegisters (string ukl1Name, unsigned feFpga, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_parseFeFpgaChannelWriteRegisters (string ukl1Name, unsigned channel, unsigned feFpga, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseFeFpgaChannelReadRegisters (string ukl1Name, unsigned channel, unsigned feFpga, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_parseGbeWriteRegisters (string ukl1Name, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseGbeReadRegisters (string ukl1Name, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_parseGbePortWriteRegisters (string ukl1Name, unsigned port, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseGbePortReadRegisters (string ukl1Name, unsigned port, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_parseTtcrxWriteRegisters (string ukl1Name, dyn_string ®isterNames, dyn_string sData, dyn_dyn_char &ddcData, dyn_dyn_char &masks, dyn_string &exceptionInfo) |
void | fwUkl1_parseTtcrxReadRegisters (string ukl1Name, const dyn_string ®isterNames, dyn_dyn_char ddcData, dyn_string &data, const dyn_int &callStatusList, dyn_string &exceptionInfo) |
void | fwUkl1_beFpgaWrite (const string &ukl1Name, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, const dyn_string &data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_beFpgaRead (const string &ukl1Name, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
void | fwUkl1_feFpgaWrite (string ukl1Name, unsigned feFpga, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, const dyn_string &data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_feFpgaRead (string ukl1Name, unsigned feFpga, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
void | fwUkl1_feFpgaChannelWrite (string ukl1Name, unsigned channel, unsigned feFpga, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, const dyn_string &data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_feFpgaChannelRead (string ukl1Name, unsigned channel, unsigned feFpga, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
void | fwUkl1_gbeWrite (string ukl1Name, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, const dyn_string &data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_gbeRead (string ukl1Name, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
void | fwUkl1_gbePortWrite (string ukl1Name, unsigned port, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, dyn_string data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_gbePortRead (string ukl1Name, unsigned port, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
void | fwUkl1_ttcrxWrite (string ukl1Name, bool writeRecipe, const dyn_string &recipeNameAndType, dyn_string registerNames, dyn_string data, bool verifyWrite, dyn_string &exceptionInfo) |
void | fwUkl1_ttcrxRead (string ukl1Name, bool readRecipe, const string &recipeName, dyn_string registerNames, dyn_string &data, dyn_string &exceptionInfo) |
string | fwUkl1_getUkl1SerialNumber (const string &ukl1Name, dyn_string &exceptionInfo) |
dyn_int | fwUkl1_getUkl1Temperatures (string ukl1Name, dyn_string &exceptionInfo) |
unsigned | _fwUkl1_fpgaizeAddress (unsigned addr) |
void | _fwUkl1_write (const string &ukl1Name, const dyn_string ®isterNames, const dyn_dyn_char &ddcData, const dyn_dyn_char &masks, bool verifyWrite, dyn_string &exceptionInfo) |
void | _fwUkl1_saveRecipe (const string &ukl1Name, const dyn_string &recipeNameAndType, const dyn_string ®isterNames, const dyn_dyn_char &ddcDataAndMask, int regType, dyn_string &exceptionInfo) |
void | _fwUkl1_verifyWrite (dyn_string registerNames, dyn_dyn_char writtenData, dyn_dyn_char masks, dyn_dyn_char readData, dyn_string &exceptionInfo) |
There are two methods for reading the values a register. It can either be done directly or via monitoring. In the case of direct reading the function fwCcpc_read() or fwHw_getRecipe() is used and the values returned by this function are parsed by fwUkl1_parseReadRegister()to remove the relevant bits from the register. It removes a continuous sections of bits and returns it as a hex string, this can then be converted into an appropriate display value. Further multiple sections of the defined size can be removed, via fwUkl1_parseReadRegisterSections(). In the case of monitoring callback functions can be setup in order to parse the data of a given data point only when it changes and again fwUkl1_parseReadRegister can be used to manipulate the register data to get at the desired information or fwUkl1_parseReadRegisterSections() if data is to be removed for example in the case of FE FPGA broadcast data. A read, using fwCcpc_read, can be used to force a reset of all monitored value, in this case the data returned by fwCcpc_read can just be ignored. This method is recommended for dealing with status registers. The library provides a function to read all the registers for a given area of the UKL1 e.g. all the BE FPGA register, and then returns them in a predefined formatted state. This is to be used in the case that monitoring is not required or the User does not wish to know or does not know the data is organised across the registers. The values returned will be in strings will often contain a description of the state rather than just a number. Again values for similar element e.g. the input channel disable states can be returned as comma separated values. This method is recommended for reading from configuration registers.
The library provides a mechanism for writing to the registers on the UKL1. It provides a wrapper for the fwCcpc_write mechanism however it provides a layer of abstraction that does not require the User to understand the layout of the registers and which registers contain multiple settings. It takes a string that typically describes the registers state and is identical to the value read in the case of the read/write configuration registers. This function is advised to be used when writing to the configuration registers.
All errors are returned by the framework defined exception handling mechanism taking an argument exceptionInfo by reference, which will contain details of an errors that occurred.
|
In order to write to specific registers on the FPGAs we must first convert the address to include the address of the FPGAs from the glue card perspective.
|
|
Save a list of recipes to the given recipe, which is of the given type. The data should contain the actual value that would be written to the hardware and include the mask that should be used when writing the data.
|
|
Reads from the registers on the L1 board to ensure that the data just written has been written successfully.
|
|
Writes the given data to the given UKL1 board. The masks are applied when writing the data to ensure that only specific bits of a register are written to.
|
|
This reads from a given set of registers on the BE FPGAs.
|
|
Writes to a given set of UKL1 registers. Data should be in a form acceptable to the fwUkl1_parseBeFpgaWriteRegisters() as it will first be passed through this function before being written to the hardware.
|
|
This takes the data that is read by from the L1 board FPGAs (LBUS), which is read as a series of 32-bit words, and converts it to a series of 16-bit words can then be decoded to return the register value.
|
|
Converts an array of bytes into a hex string and treats the dyn_char array as if it were little endian.
|
|
Takes an array of bytes, and returns them as a full stop delimited IP address.
Example (...) //Fictional UKL1 board name, as found in the DIM server. const string ukl1Name = "pcukl101"; //Register name needs to be the full DP name, hence requires the HW DP name prefix defined by this library. dyn_string registerNames; registerNames[1] = FWUKL1_HW_DP_NAME_PREFIX + ukl1Name + ".BeFpga.IpDestinationAddress" //Stores the read data. dyn_char readData; //Holds errors. dyn_int callStatusList; //Read and save the status. const bool readStatus = fwCcpc_read(registerNames, ddcData, callStatusList); //Check for errors... if (!readStatus) (...) fwUkl1_convert32To16BitWord(ddcData[1], exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle errors, should be none if read successful... const string ipAddress = fwUkl1_convertByteToIp(ddcData[1], exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle errors, should be none if read successful... DebugTN(ipAddress); //Colon delimited MAC address e.g. 192.168.255.0 (...) |
|
Takes an array of bytes and returns them as a colon delimited MAC address.
Example (...) //Fictional UKL1 board name, as found in the DIM server. const string ukl1Name = "pcukl101"; //Register name needs to be the full DP name, hence requires the HW DP name prefix defined by this library. dyn_string registerNames; registerNames[1] = FWUKL1_HW_DP_NAME_PREFIX + ukl1Name + ".BeFpga.MacDestinationAddress" //Stores the read data. dyn_char readData; //Holds errors. dyn_int callStatusList; //Read and save the status. const bool readStatus = fwCcpc_read(registerNames, ddcData, callStatusList); //Check for errors... if (!readStatus) (...) fwUkl1_convert32To16BitWord(ddcData[1], exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle errors, should be none if read successful... const string macAddress = fwUkl1_convertByteToMac(ddcData[1], exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle errors, should be none if read successful... DebugTN(macAddress); //Colon delimited MAC address e.g. 00:0E:0C:B0:2D:19 (...) |
|
Takes a standard formed IP(4) address, as a string, and convert it to a continuous hex string. Also performs syntacs checking on the given string.
(...) //An IP address that we wish to convert. const string ipAddress1 = 192.168.255.1; //The equivalent hex string. const string hexAddress1 = fwUkl1_convertIpToHex(ipAddress1, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Will not have any error... DebugTN(hexAddress1); //c0a8ff01 //An IP address that we wish to convert. const string ipAddress2 = 192.168.255; //The equivalent hex string. const string hexAddress2 = fwUkl1_convertIpToHex(ipAddress1, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Will not have any error... DebugTN(hexAddress2); //c0a8ff00, note the last byte are zeros. //Invalid IP address. const string ipAddress3 = 192.168.; const string hexAddress3 = fwUkl1_convertIpToHex(ipAddress2, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle error... DebugTN(hexAddress3); //Fail (...) |
|
Takes a colon delimited hex MAC address, as a string, and removes the colons to return a continuous hex string. It also performs checks on the data format.
(...) //A colon delimited MAC address that we wish to convert. const string macAddress1 = 00:0e:0c:b0:2d:19; //A colonless MAC address. const string hexAddress1 = fwUkl1_convertMacToHex(macAddress1, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Will not have any error... DebugTN(hexAddress1); //000e0cb02d19 //A colon delimited MAC address that we wish to convert. const string macAddress2 = 00:0e:0c:b0; //A colonless MAC address. const string hexAddress2 = fwUkl1_convertMacToHex(macAddress1, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Will not have any error... DebugTN(hexAddress2); //000e0cb00000 //Invalid colon separated MAC address. const string macAddress3 = 00:0e:0c:b0:2d; const string hexAddress3 = fwUkl1_convertMacToHex(macAddress2, exceptionInfo); if ( 0 != dynlen(exceptionInfo) ) //...Handle error... DebugTN(hexAddress3); //Fail (...) |
|
This reads from a given set of registers on a FE FPGA channel. It can read from a single FE FPGA channel or all the channels on a FE FPGA in broadcast mode. The reads can either be from the hardware or they can be done from a configurationDB recipe. If reading from a recipe broadcast mode must be used.
|
|
This writes to a given set of registers on a FE FPGA channel. It can be used to write to either the registers on the UKL1 board or to a configurationDB recipe. If writing to a recipe broadcast mode must be used.
|
|
This reads from a given set of registers on the FE FPGAs. It is capable of reading from either an individual FE FPGA or all FE FPGAs in broadcast mode. The source of the data can be either the UKL1 board or a recipe. If reading from a recipe the broadcast FPGA must be used.
|
|
Writes to a given set of UKL1 registers. Data should be in a form acceptable to the fwUkl1_parseFeFpgaWriteRegisters() as it will first be passed through this function before being written to the hardware.
|
|
This reads from a given set of GBE port registers. The reads can either be from the hardware or they can be done from a configurationDB recipe.
|
|
This writes to a given set of registers on a GBE port. It can be used to write to either the registers on the UKL1 board or to a configurationDB recipe.
|
|
This reads from a given set of general GBE registers. The reads can either be from the hardware or they can be done from a configurationDB recipe.
|
|
This writes to a given set of registers on the giga-bit ethernet (GBE) card. It can be used to write to either the registers on the UKL1 board or to a configurationDB recipe.
|
|
A function to read the serial number from a UKl1 board.
|
|
This function allows the temperature probes to be read.
|
|
Takes a string and ensures that it contains enough characters for the number of bytes specified by numBytes. Adds `0' to the beginnig if it is too short and removes characters from the beginning if it is too long. Must be in hex.
Example: (...) //Declare some data e.g. User input from a panel. const string hexData1 = "1234"; //Wish to use the fwCcpc library to write this to a 32-bit registers hence is needs to be zero padded //to be 4-bytes big (8-characters). const string paddedData1 = fwUkl1_padString(hexData1, 4); DebugTN(paddedData1); // "00001234" //Declare some more data e.g. User input from a panel. const string hexData2 = "1234"; //Wish to use the fwCcpc library to write this to an 8-bit registers hence it need to be 1-byte (2-characters) big. const string paddedData2 = fwUkl1_padString(hexData2, 1); //Here the data is misformed and it is assumed that the least significant bit (last character) in the given number //should remain the least significant bit. DebugTN(paddedData2); // "34" (...) |
|
Takes the data read from the BE FPGA configuration registers using fwCcpc_read or from a recipe and converts them to strings to provide a description of the register setting. It also splits settings that occupy the same register address into their own description.
|
|
This function takes the data for the various BE FPGA registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
This takes a array of string where each element of the array contains the relevant settings for either the FE FPGAs, the channels on a FE FPGA or the GBE ports and converts these to an array of strings. The returned result is an array of array of strings that contain all the relevant settings.
|
|
Takes the data read from the FE FPGA channel configuration registers using fwCcpc_read or from a recipe and converts them to string to provide a description of the register setting. It also splits settings that occupy the same register address into their own description.
|
|
This function takes the data for the various FE FPGA channel registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
Takes the data read from the FE FPGA configuration registers using fwCcpc_read or a recipe and converts them to string to provide a description of the register setting. It also splits settings that occupy the same register address into their own description.
|
|
This function takes the data for the various FE FPGA registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
This takes the data read from the GBE port registers in the format as read from fwCcpc_read() or fwHw_getRecipe() and returns the values as a decriptive string.
|
|
This function takes the data for the various GBE registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
This takes the data read from the GBE registers in the format as read from fwCcpc_read() or fwHw_getRecipe() and returns the values as a decriptive string.
|
|
This function takes the data for the various GBE registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
The purpose of this function is to take the data read from the UKL1 registers and to allow a specific group of continuous bits to be returned as a integer. The function poses the ability to deal with registers of any size e.g. the 32-bit registers from the GBE or FPGAs, or the 8-bit registers from the I2C. It is also capable of dealing with the format of the FPGA registers as read from the UKL1s and a boolean switch it used to indicate that these must be handled. Typically this will be used with monitored registers.
Example:
(...) //Fictional UKL1 board name, as found in the DIM server. const string ukl1Name = "pcukl101"; //Register name needs to be the full DP name, hence requires the HW DP name prefix defined by this library. dyn_string registerNames; registerNames[1] = FWUKL1_HW_DP_NAME_PREFIX + ukl1Name + ".BeFpga.ZeroSuppression" //Stores the read data. dyn_char readData; //Holds errors. dyn_int callStatusList; //Read and save the status. const bool readStatus = fwCcpc_read(registerNames, ddcData, callStatusList); //Check for errors... if (!readStatus) (...) //Data read from the zero suppression register contains also the HPD pixel mode data which we are not interested in, //hence this function will return only the zero suppression data. //Zero suppression data spans 4 bits, starting with the least significant bit. const unsigned startBit = 0; const unsigned length = 4; //The zero suppression setting is on a FPGA register. const bool fpga = TRUE; //Check for errors. dyn_string exceptionInfo; //Convert the data. const int zeroSuppData = fwUkl1_parseReadRegister(ddcData[1], startBit, length, fpga, exceptionInfo); //Check for errors. if ( 0 < dynlen(exceptionInfo) ) (...) //If zero suppression is enabled then 0xf would be returned. if ( 0xf == zeroSuppData ) (...zero suppressed code...) else if ( 0 == zeroSuppData ) (...none zero suppressed code...) else (...-1 would be seen if an error occur, which should have been handled after function call, need to check anyway otherwise it might be dealt with by an above case...) (...)
|
|
The purpose of this function is to take the data read from the UKL1 registers and to allow multiple groups of continuous bits to be return in the form of a integer array. The function poses the ability to deal with registers of any size e.g. the 32-bit registers from the GBE or FPGAs, or the 8-bit registers from the I2C. It is also capable of dealing with the format of the FPGA registers as read from the UKL1s and a boolean switch it used to indicate that these must be handled. Typically this will be used with monitored registers.
The reason for the FPGA flag is that the UKL1 FPGA registers are read as if they were 32-bit registers and not the 16-bit registers that they are physically (this is because sequential addresses are 32-bits apart and not 16!). This function will remove the extra two junk words that are read and parse only the remaining data in this case. Do not remove these extra words manually before hand. This function can return sections that are a maximum of 32-bits in length. The only registers that are bigger than this are the MAC addresses and these have their own dedicated convertion functions. The input size of the register is unlimited. Example:
(...) //Fictional UKL1 board name, as found in the DIM server. const string ukl1Name = "pcukl101"; //Register name needs to be the full DP name, hence requires the HW DP name prefix defined by this library. dyn_string registerNames; registerNames[1] = FWUKL1_HW_DP_NAME_PREFIX + ukl1Name + ".FeFpga0.disable" //Stores the read data. dyn_char readData; //Holds errors. dyn_int callStatusList; //Read and save the status. const bool readStatus = fwCcpc_read(registerNames, ddcData, callStatusList); //Check for errors... if (!readStatus) (...) //Data read from the disable register on the FE FPGA contains the disable settings for all the FE FPGA disable setting. //we split this data up into 4 settings, thus requiring only one read to get all the data. //Number of sections wanted is the number of FE FPGAs. const unsigned numSections = FWUKL1_FRONT_FPGAS; //The settings are in adjacent bits. const unsigned sectionGap = 0; //The data is a single bit, the first one starting at bit zero. const unsigned startBit = 0; const unsigned length = 1; //The it is a setting on an FPGA register. const bool fpga = TRUE; //Check for errors. dyn_string exceptionInfo; //Convert the data. const dyn_int feFpgaDisableData = fwUkl1_parseReadRegisterSections(ddcData[1], numSections, sectionGap, startBit, length, fpga, exceptionInfo); //Check for errors. if ( 0 < dynlen(exceptionInfo) ) (...) //Let us deal with all four settings. for (int feFgpa = 1; feFpga <= FWUKL1_FRONT_FPGAS; ++feFpga) { if ( 1 == feFpgaDisableData[feFpga] ) (...disabled code...) else if ( 0 == feFpgaDisableData[feFpga] ) (...enabled code...) else (...-1 would be seen if an error occur, which should have been handled after function call, need to check anyway otherwise it might be dealt with by an above case...) (...)
|
|
This takes the data read from the TTCrx registers in the format as read from fwCcpc_read() or fwHw_getRecipe() and returns the values as a decriptive string.
|
|
This function takes the data for the various TTCrx registers described by a string and converts it to data that can used with fwCcpc_write() or fwHw_saveRecipe(). It allows data to be given in a more human readable format and converts it to the byte array required for writting to the CCPC. It also returns the appropriate mask that must be used when writing the data. If being used with fwHw_saveRecipe() then the mask will have to be appended to the data array.
|
|
This reads from a given set of TTCrx registers. The reads can either be from the hardware or they can be done from a configurationDB recipe.
|
|
This writes to a given set of registers on TTCrx. It can be used to write to either the registers on the UKL1 board or to a configurationDB recipe.
|