/**	@file BoardControllerCommandCoder.C
 *
 *	@brief The BoardControllerCommandCoder class implements the transofrmation of BoardController Parameters into commands
 *
 *	This Class transforms Configuration settings fo the Board Controller of the Front end Card
 *	in the appropriate Assembled form\n
 *	Each function to compose a Board Controller Command with data is returning a uint64_t. The Command and the
 *	Adressing is in the first 32 bit, the data follows in the second 32 bit word. In both cases the lower
 * 	20 bit are containing the command data.\n
 *      Each function without data is returned as a 32 uint32_t, again the lower 20 bit hold the coded command.\n
 *	There are also functions to compose and decompose the various Board Controller Registers and the error states\n
 */

#include "BoardControllerCommandCoder.h"

//===========================================================================
BoardControllerCommandCoder::BoardControllerCommandCoder(){
  kT_THFactor  = 0.25;
  kAV_THFactor = 0.00443;
  kAC_THFactor = 0.017;
  kDV_THFactor = 0.00443;
  kDC_THFactor = 0.030;
}

//===========================================================================
BoardControllerCommandCoder::~BoardControllerCommandCoder(){
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendT_TH(uint32_t branch, uint32_t FECaddr, uint32_t temperaturThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(T_TH))<<32) + (temperaturThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendT_TH(uint32_t temperaturThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(T_TH))<<32) + (temperaturThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendAV_TH(uint32_t branch, uint32_t FECaddr, uint32_t AVThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AV_TH))<<32) + (AVThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendAV_TH(uint32_t AVThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(AV_TH))<<32) + (AVThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendAC_TH(uint32_t branch, uint32_t FECaddr, uint32_t ACThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AC_TH))<<32) + (ACThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendAC_TH(uint32_t ACThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(AC_TH))<<32) + (ACThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendDV_TH(uint32_t branch, uint32_t FECaddr, uint32_t DVThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DV_TH))<<32) + (DVThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendDV_TH(uint32_t DVThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(DV_TH))<<32) + (DVThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendDC_TH(uint32_t branch, uint32_t FECaddr, uint32_t DCThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DC_TH))<<32) + (DCThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendDC_TH(uint32_t DCThreshold){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(DC_TH))<<32) + (DCThreshold&ci10BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendTSMWORD(uint32_t branch, uint32_t FECaddr, uint32_t valueTSMWORD){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(TSMWORD))<<32) + (valueTSMWORD&ci09BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendTSMWORD(uint32_t valueTSMWORD){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(TSMWORD))<<32) + (valueTSMWORD&ci09BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendUSRATIO(uint32_t branch, uint32_t FECaddr, uint32_t valueUSRATIO){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(USRATIO))<<32) + (valueUSRATIO&ci16BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendUSRATIO(uint32_t valueUSRATIO){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(USRATIO))<<32) + (valueUSRATIO&ci16BitOn);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR0(uint32_t branch, uint32_t FECaddr, uint32_t valueCSR0){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR0))<<32) + (valueCSR0);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR0(uint32_t valueCSR0){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CSR0))<<32) + (valueCSR0);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR1(uint32_t branch, uint32_t FECaddr, uint32_t valueCSR1){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR1))<<32) + (valueCSR1);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR1(uint32_t valueCSR1){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CSR1))<<32) + (valueCSR1);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR2(uint32_t branch, uint32_t FECaddr, uint32_t valueCSR2){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR2))<<32) + (valueCSR2);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR2(uint32_t valueCSR2){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CSR2))<<32) + (valueCSR2);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR3(uint32_t branch, uint32_t FECaddr, uint32_t valueCSR3){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR3))<<32) + (valueCSR3);
  return retval;
}

//===========================================================================
uint64_t BoardControllerCommandCoder::sendCSR3(uint32_t valueCSR3){
  uint64_t retval;
  retval =  ((uint64_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CSR3))<<32) + (valueCSR3);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCNTLAT(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CNTLAT)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCNTLAT(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), 0, 0, eBCRegAddr(CNTLAT)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCNTCLR(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CNTCLR)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCNTCLR(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CNTCLR)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCSR1CLR(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR1CLR)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendCSR1CLR(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(CSR1CLR)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendALRST(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(ALRST)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendALRST(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(ALRST)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendBCRST(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(BCRST)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendBCRST(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(BCRST)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendSTCNV(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(STCNV)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::sendSTCNV(){
  uint32_t retval;
  retval =  ((uint32_t)instruction(eScope(BROADCAST), 0, 0, eBCRegAddr(STCNV)));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveT_TH(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(T_TH));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveAV_TH(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AV_TH));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveAC_TH(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AC_TH));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveDV_TH(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DV_TH));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveDC_TH(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DC_TH));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveTEMP(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(TEMP));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveAV(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AV));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveAC(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(AC));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveDV(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DV));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveDC(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DC));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveL1CNT(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(L1CNT));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveL2CNT(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(L2CNT));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveSCLKCNT(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(SCLKCNT));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveDSTBCNT(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(DSTBCNT));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveTSMWORD(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(TSMWORD));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveUSRATIO(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(USRATIO));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveCSR0(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR0));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveCSR1(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR1));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveCSR2(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR2));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::receiveCSR3(uint32_t branch, uint32_t FECaddr){
  uint32_t retval;
  retval = instruction(eScope(LOCAL), branch, FECaddr, eBCRegAddr(CSR3));
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeT_TH(float temperaturThreshold){
  //for negative use 2th complement. Max = 127
  return (((uint32_t)(temperaturThreshold/kT_THFactor))&ci10BitOn);
}

//===========================================================================
float BoardControllerCommandCoder::decodeT_TH(uint32_t temperaturThreshold){
  return (float)((temperaturThreshold&ci10BitOn)*kT_THFactor);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeAV_TH(float AVThreshold){
  return (((uint32_t)(AVThreshold/kAV_THFactor))&ci10BitOn);
}

//===========================================================================
float BoardControllerCommandCoder::decodeAV_TH(uint32_t AVThreshold){
  return (float)((AVThreshold&ci10BitOn)*kAV_THFactor);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeAC_TH(float ACThreshold){
  return (((uint32_t)(ACThreshold/kAC_THFactor))&ci10BitOn);
}

//===========================================================================
float BoardControllerCommandCoder::decodeAC_TH(uint32_t ACThreshold){
  return (float)((ACThreshold&ci10BitOn)*kAC_THFactor);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeDV_TH(float DVThreshold){
  return (((uint32_t)(DVThreshold/kDV_THFactor))&ci10BitOn);
}

//===========================================================================
float BoardControllerCommandCoder::decodeDV_TH(uint32_t DVThreshold){
  return (float)((DVThreshold&ci10BitOn)*kDV_THFactor);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeDC_TH(float DCThreshold){
  return (((uint32_t)(DCThreshold/kDC_THFactor))&ci10BitOn);
}

//===========================================================================
float BoardControllerCommandCoder::decodeDC_TH(uint32_t DCThreshold){
  return (float)((DCThreshold&ci10BitOn)*kDC_THFactor);
}

//===========================================================================
bool BoardControllerCommandCoder::decodeCSR1(eCSR1 bit, uint32_t valueCSR1){
  bool retval;
  retval = ((valueCSR1&(1<<bit))>>bit);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeCSR2(uint32_t HADD, uint32_t selftest, uint32_t AltroTestMode,
						   uint32_t clock_en, uint32_t paps_en){
  uint32_t retval;
  retval = ((HADD&ci05BitOn)<<11) + ((selftest&1)<<10) + ((AltroTestMode&ci06BitOn)<<4) + ((clock_en&ci02BitOn)<<2)
    + (paps_en&ci02BitOn);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeAltroTestMode(uint32_t TSMOnOff, uint32_t AltroAddress,
							    uint32_t adc_add1, uint32_t adc_add0){
  uint32_t retval;
  retval = ((TSMOnOff&1)<<5) + ((AltroAddress&ci03BitOn)<<2) + ((adc_add1&1)<<1) + (adc_add0&1);
  return retval;
}
//===========================================================================
uint32_t BoardControllerCommandCoder::codeclock_en(uint32_t adcclk_en, uint32_t rdoclk_en){
  uint32_t retval;
  retval = ((adcclk_en&1)<<1) + (rdoclk_en&1);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codepaps_en(uint32_t pasa_se, uint32_t altro_sw){
  uint32_t retval;
  retval = ((pasa_se&1)<<1) + (altro_sw&1);
  return retval;
}

//===========================================================================
bool BoardControllerCommandCoder::decodeCSR2(eCSR1 bit,uint32_t valueCSR2){
  bool retval;
  retval = ((valueCSR2&(1<<bit))>>bit);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR2_HADD(uint32_t valueCSR2){
  return (valueCSR2>>11);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR2_ATM_AltroAddress(uint32_t valueCSR2){
  return ((valueCSR2>>6)&ci03BitOn);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeCSR3(uint32_t cnvend, uint32_t rdclkDIFFsclkRatio){
  uint32_t retval;
  retval = ((cnvend&1)<<15) + (rdclkDIFFsclkRatio&ci08BitOn);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR3_rdclkDIFFsclkRatio(uint32_t valueCSR3){
  return (valueCSR3&ci08BitOn);
}

//===========================================================================
bool BoardControllerCommandCoder::decodeCSR3_cnvend(uint32_t valueCSR3){
  return ((valueCSR3>>15)&1);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeCSR0(uint32_t ADCmode, uint32_t EMASK, uint32_t IMASK) {
  uint32_t retval;
  retval = ((ADCmode&1)<<10) + ((EMASK&ci02BitOn)<<8) + (IMASK&ci08BitOn);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR0_ADCmode(uint32_t valueCSR0) {
  return ((valueCSR0>>10)&1);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR0_EMASK(uint32_t valueCSR0) {
  return ((valueCSR0>>8)&ci02BitOn);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::decodeCSR0_IMASK(uint32_t valueCSR0) {
  return (valueCSR0&ci08BitOn);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::codeAddress(//===========================================================================
uint32_t Branch, uint32_t FECaddr){
  return ((Branch&1)<<11) + ((FECaddr&ci04BitOn)<<7);
}

//===========================================================================
uint32_t BoardControllerCommandCoder::getDecodedAddressBranch(uint32_t Address){
  return ((Address>>11)&1);
}

//===========================================================================
//===========================================================================
uint32_t BoardControllerCommandCoder::getDecodedAddressFECaddr(uint32_t Address){
  return ((Address>>7)&ci04BitOn);
}

//===========================================================================
//===========================================================================
uint32_t BoardControllerCommandCoder::instruction(eScope broadcast, uint32_t branch, uint32_t FECaddr,
						      eBCRegAddr registerAddress){
  // get ALTRO bus instruction
  int32_t retval;
  int32_t data = (int)((broadcast<<18) +  (1<<17) /* BC */ + ((branch&1)<<16) + ((FECaddr&ci04BitOn)<<12)
		   + (registerAddress));
  int32_t parity = 0; //getParity(data&ci19BitOn);
  retval = ((int)parity<<19) + ((int)data&ci19BitOn);
  return retval;
}

//===========================================================================
uint32_t BoardControllerCommandCoder::getParity(uint32_t data) { 
  // get parity of integer 'data'
  uint32_t no_of_ones = 0;
  while ( data != 0 ) {
    no_of_ones++; 
    data &= (data-1);            // the loop will execute once for each bit of data set 
  }
  return (no_of_ones&ci01BitOn); // if no_of_ones is odd, least significant bit will be 1
}