gccDppConsole Test C++ SDK  1.0.0.0
DPP C++ Console Demonstration
DeviceIO/DP5Status.cpp
Go to the documentation of this file.
00001 #include "DP5Status.h"
00002 #include "stringex.h"
00003 #include "DppConst.h"
00004 
00005 CDP5Status::CDP5Status(void)
00006 {
00007 }
00008 
00009 CDP5Status::~CDP5Status(void)
00010 {
00011 }
00012 
00013 void CDP5Status::Process_Status(DP4_FORMAT_STATUS *m_DP5_Status)
00014 {
00015         bool bDMCA_LiveTime = false;
00016 
00017         m_DP5_Status->DEVICE_ID = m_DP5_Status->RAW[39];
00018     m_DP5_Status->FastCount = DppUtil.LongWordToDouble(0, m_DP5_Status->RAW);
00019     m_DP5_Status->SlowCount = DppUtil.LongWordToDouble(4, m_DP5_Status->RAW);
00020     m_DP5_Status->GP_COUNTER = DppUtil.LongWordToDouble(8, m_DP5_Status->RAW);
00021     m_DP5_Status->AccumulationTime = (float)m_DP5_Status->RAW[12] * 0.001 + (float)(m_DP5_Status->RAW[13] + (float)m_DP5_Status->RAW[14] * 256.0 + (float)m_DP5_Status->RAW[15] * 65536.0) * 0.1;
00022         m_DP5_Status->RealTime = ((double)m_DP5_Status->RAW[20] + ((double)m_DP5_Status->RAW[21] * 256.0) + ((double)m_DP5_Status->RAW[22] * 65536.0) + ((double)m_DP5_Status->RAW[23] * 16777216.0)) * 0.001;
00023 
00024         m_DP5_Status->Firmware = m_DP5_Status->RAW[24];
00025     m_DP5_Status->FPGA = m_DP5_Status->RAW[25];
00026         
00027         if (m_DP5_Status->Firmware > 0x65) {
00028                 m_DP5_Status->Build = m_DP5_Status->RAW[37] & 0xF;              //Build # added in FW6.06
00029         } else {
00030                 m_DP5_Status->Build = 0;
00031         }
00032 
00033         //Firmware Version:  6.07  Build:  0 has LiveTime and PREL
00034         //DEVICE_ID 0=DP5,1=PX5,2=DP5G,3=MCA8000D,4=TB5
00035         if (m_DP5_Status->DEVICE_ID == dppMCA8000D) {
00036                 if (m_DP5_Status->Firmware >= 0x67) {
00037                         bDMCA_LiveTime = true;
00038                 }
00039         }
00040 
00041         if (bDMCA_LiveTime) {
00042                 m_DP5_Status->LiveTime = ((double)m_DP5_Status->RAW[16] + ((double)m_DP5_Status->RAW[17] * 256.0) + ((double)m_DP5_Status->RAW[18] * 65536.0) + ((double)m_DP5_Status->RAW[19] * 16777216.0)) * 0.001;
00043         } else {
00044                 m_DP5_Status->LiveTime = 0;
00045         }
00046 
00047     if (m_DP5_Status->RAW[29] < 128) {
00048         m_DP5_Status->SerialNumber = (unsigned long)DppUtil.LongWordToDouble(26, m_DP5_Status->RAW);
00049     } else {
00050         m_DP5_Status->SerialNumber = -1;
00051     }
00052     
00053         // m_DP5_Status->HV = (double)(m_DP5_Status->RAW[31] + (m_DP5_Status->RAW[30] & 15) * 256) * 0.5;                                       // 0.5V/count
00054 
00055         if (m_DP5_Status->RAW[30] < 128)  {    // not negative
00056         m_DP5_Status->HV = ((double)m_DP5_Status->RAW[31] + ((double)m_DP5_Status->RAW[30] * 256.0)) * 0.5;  // 0.5V/count
00057         } else {
00058                 m_DP5_Status->HV = (((double)m_DP5_Status->RAW[31] + ((double)m_DP5_Status->RAW[30] * 256)) - 65536.0) * 0.5; // 0.5V/count
00059         }
00060       
00061         m_DP5_Status->DET_TEMP = (double)((m_DP5_Status->RAW[33]) + (m_DP5_Status->RAW[32] & 15) * 256) * 0.1; // - 273.16;             // 0.1K/count
00062     m_DP5_Status->DP5_TEMP = m_DP5_Status->RAW[34] - ((m_DP5_Status->RAW[34] & 128) * 2);
00063 
00064     m_DP5_Status->PresetRtDone = ((m_DP5_Status->RAW[35] & 128) == 128);
00065 
00066         //BYTE:35 BIT:D6 
00067         // == Preset LiveTime Done for MCA8000D
00068         // == FAST Thresh locked for other dpp devices
00069         m_DP5_Status->PresetLtDone = false;
00070         m_DP5_Status->AFAST_LOCKED = false;
00071         if (bDMCA_LiveTime) {           // test for MCA8000D
00072                 m_DP5_Status->PresetLtDone = ((m_DP5_Status->RAW[35] & 64) == 64);
00073         } else {
00074                 m_DP5_Status->AFAST_LOCKED = ((m_DP5_Status->RAW[35] & 64) == 64);
00075         }
00076     m_DP5_Status->MCA_EN = ((m_DP5_Status->RAW[35] & 32) == 32);
00077     m_DP5_Status->PRECNT_REACHED = ((m_DP5_Status->RAW[35] & 16) == 16);
00078     m_DP5_Status->SCOPE_DR = ((m_DP5_Status->RAW[35] & 4) == 4);
00079     m_DP5_Status->DP5_CONFIGURED = ((m_DP5_Status->RAW[35] & 2) == 2);
00080 
00081     m_DP5_Status->AOFFSET_LOCKED = ((m_DP5_Status->RAW[36] & 128) == 0);  // 0=locked, 1=searching
00082     m_DP5_Status->MCS_DONE = ((m_DP5_Status->RAW[36] & 64) == 64);
00083 
00084     m_DP5_Status->b80MHzMode = ((m_DP5_Status->RAW[36] & 2) == 2);
00085     m_DP5_Status->bFPGAAutoClock = ((m_DP5_Status->RAW[36] & 1) == 1);
00086 
00087     m_DP5_Status->PC5_PRESENT = ((m_DP5_Status->RAW[38] & 128) == 128);
00088     if  (m_DP5_Status->PC5_PRESENT) {
00089         m_DP5_Status->PC5_HV_POL = ((m_DP5_Status->RAW[38] & 64) == 64);
00090         m_DP5_Status->PC5_8_5V = ((m_DP5_Status->RAW[38] & 32) == 32);
00091     } else {
00092         m_DP5_Status->PC5_HV_POL = false;
00093         m_DP5_Status->PC5_8_5V = false;
00094     }
00095 
00096         //m_DP5_Status->DPP_options = 0;
00097         //if (m_DP5_Status->DEVICE_ID == dppPX5) {              // test for px5 options
00098         //      // HPGe HVPS installed
00099         //      m_DP5_Status->DPP_options = ((m_DP5_Status->RAW[42] & 1) == 1);
00100         //} 
00101 
00102         if (m_DP5_Status->Firmware >= 0x65) {           // reboot flag added FW6.05
00103                 if ((m_DP5_Status->RAW[36] & 32) == 32) {
00104             m_DP5_Status->ReBootFlag = true;
00105                 } else {
00106                         m_DP5_Status->ReBootFlag = false;
00107                 }
00108         } else {
00109         m_DP5_Status->ReBootFlag = false;
00110         }
00111 
00112         m_DP5_Status->TEC_Voltage = (((double)(m_DP5_Status->RAW[40] & 15) * 256.0) + (double)(m_DP5_Status->RAW[41])) / 758.5;
00113         m_DP5_Status->DPP_ECO = m_DP5_Status->RAW[49];
00114         m_DP5_Status->DPP_options = (m_DP5_Status->RAW[42] & 15);
00115         m_DP5_Status->HPGe_HV_INH = false;
00116         m_DP5_Status->HPGe_HV_INH_POL = false;
00117         m_DP5_Status->AU34_2 = false;
00118         m_DP5_Status->isAscInstalled = false;
00119         if (m_DP5_Status->DEVICE_ID == dppPX5) {
00120                 if (m_DP5_Status->DPP_options == PX5_OPTION_HPGe_HVPS) {
00121                         m_DP5_Status->HPGe_HV_INH = ((m_DP5_Status->RAW[42] & 32) == 32);
00122                         m_DP5_Status->HPGe_HV_INH_POL = ((m_DP5_Status->RAW[42] & 16) == 16);
00123                         if (m_DP5_Status->DPP_ECO == 1) {
00124                                 m_DP5_Status->isAscInstalled = true;
00125                                 m_DP5_Status->AU34_2 = ((m_DP5_Status->RAW[42] & 64) == 64);
00126                         }
00127                 }
00128         } 
00129 }
00130 
00131 string CDP5Status::ShowStatusValueStrings(DP4_FORMAT_STATUS m_DP5_Status) 
00132 { 
00133     string strConfig("");
00134     string strTemp;
00135         string strIntPart;
00136         string strFracPart;
00137         stringex strfn;
00138 
00139         strTemp = GetDeviceNameFromVal(m_DP5_Status.DEVICE_ID);
00140         strConfig = "Device Type: " + strTemp + "\r\n";
00141         strTemp = strfn.Format("Serial Number: %lu\r\n",m_DP5_Status.SerialNumber);     //SerialNumber
00142         strConfig += strTemp;
00143         strTemp = "Firmware: " + DppUtil.BYTEVersionToCString(m_DP5_Status.Firmware);   
00144         strConfig += strTemp;
00145         if (m_DP5_Status.Firmware > 0x65) {
00146                 strTemp = strfn.Format("  Build:  %d\r\n", m_DP5_Status.Build);
00147                 strConfig += strTemp;
00148         } else {
00149                 strConfig += "\r\n";
00150         }               
00151         strTemp = "FPGA: " + DppUtil.BYTEVersionToCString(m_DP5_Status.FPGA) + "\r\n"; 
00152         strConfig += strTemp;
00153         if (m_DP5_Status.DEVICE_ID != dppMCA8000D) {
00154                 strTemp = strfn.Format("Fast Count: %.0f\r\n",m_DP5_Status.FastCount);          //FastCount
00155                 strConfig += strTemp;
00156         }
00157         strTemp = strfn.Format("Slow Count: %.0f\r\n",m_DP5_Status.SlowCount);          //SlowCount
00158         strConfig += strTemp;
00159         strTemp = strfn.Format("GP Count: %.0f\r\n",m_DP5_Status.GP_COUNTER);           //GP Count
00160         strConfig += strTemp;
00161 
00162         if (m_DP5_Status.DEVICE_ID != dppMCA8000D) {
00163                 strTemp = strfn.Format("Accumulation Time: %.0f\r\n",m_DP5_Status.AccumulationTime);        //AccumulationTime
00164                 strConfig += strTemp;
00165         }
00166 
00167         strTemp = strfn.Format("Real Time: %.0f\r\n",m_DP5_Status.RealTime);        //RealTime
00168         strConfig += strTemp;
00169 
00170         if (m_DP5_Status.DEVICE_ID == dppMCA8000D) {
00171                 strTemp = strfn.Format("Live Time: %.0f\r\n",m_DP5_Status.LiveTime);        //RealTime
00172                 strConfig += strTemp;
00173         }
00174 
00175         return strConfig;
00176 }
00177 
00178 string CDP5Status::PX5_OptionsString(DP4_FORMAT_STATUS m_DP5_Status)
00179 {
00180         string strOptions("");
00181         string strValue("");
00182 
00183         if (m_DP5_Status.DEVICE_ID == dppPX5) {
00184         //m_DP5_Status.DPP_options = 1;
00185         //m_DP5_Status.HPGe_HV_INH = true;
00186         //m_DP5_Status.HPGe_HV_INH_POL = true;
00187         if (m_DP5_Status.DPP_options > 0) {
00188             //===============PX5 Options==================
00189             strOptions += "PX5 Options: ";
00190             if ((m_DP5_Status.DPP_options & 1) == 1) {
00191                 strOptions += "HPGe HVPS\r\n";
00192             } else {
00193                 strOptions += "Unknown\r\n";
00194             }
00195             //===============HPGe HVPS HV Status==================
00196             strOptions += "HPGe HV: ";
00197             if (m_DP5_Status.HPGe_HV_INH) {
00198                 strOptions += "not inhibited\r\n";
00199             } else {
00200                 strOptions += "inhibited\r\n";
00201             }
00202             //===============HPGe HVPS Inhibit Status==================
00203             strOptions += "INH Polarity: ";
00204             if (m_DP5_Status.HPGe_HV_INH_POL) {
00205                 strOptions += "high\r\n";
00206             } else {
00207                 strOptions += "low\r\n";
00208             }
00209         } else {
00210             strOptions += "PX5 Options: None\r\n";  //           strOptions += "No Options Installed"
00211         }
00212     }
00213         return strOptions; 
00214 }
00215 
00216 string CDP5Status::GetStatusValueStrings(DP4_FORMAT_STATUS m_DP5_Status) 
00217 { 
00218     string strConfig("");
00219     string strTemp;
00220         string strIntPart;
00221         string strFracPart;
00222         stringex strfn;
00223 
00224         strTemp = GetDeviceNameFromVal(m_DP5_Status.DEVICE_ID);
00225         strConfig = "Device Type: " + strTemp + "\r\n";
00226         strTemp = strfn.Format("Serial Number: %lu\r\n",m_DP5_Status.SerialNumber);     //SerialNumber
00227         strConfig += strTemp;
00228         strTemp = "Firmware: " + DppUtil.BYTEVersionToCString(m_DP5_Status.Firmware);   
00229         strConfig += strTemp;
00230         if (m_DP5_Status.Firmware > 0x65) {
00231                 strTemp = strfn.Format("  Build:  %d\r\n", m_DP5_Status.Build);
00232                 strConfig += strTemp;
00233         } else {
00234                 strConfig += "\r\n";
00235         }
00236         strTemp = "FPGA: " + DppUtil.BYTEVersionToCString(m_DP5_Status.FPGA) + "\r\n"; 
00237         strConfig += strTemp;
00238         if (m_DP5_Status.DEVICE_ID != dppMCA8000D) {
00239                 strTemp = strfn.Format("Fast Count: %.0f\r\n",m_DP5_Status.FastCount);          //FastCount
00240                 strConfig += strTemp;
00241         }
00242         strTemp = strfn.Format("Slow Count: %.0f\r\n",m_DP5_Status.SlowCount);          //SlowCount
00243         strConfig += strTemp;
00244         strTemp = strfn.Format("GP Count: %.0f\r\n",m_DP5_Status.GP_COUNTER);           //GP Count
00245         strConfig += strTemp;
00246 
00247         if (m_DP5_Status.DEVICE_ID != dppMCA8000D) {
00248                 strTemp = strfn.Format("Accumulation Time: %.0f\r\n",m_DP5_Status.AccumulationTime);        //AccumulationTime
00249                 strConfig += strTemp;
00250         }
00251 
00252         strTemp = strfn.Format("Real Time: %.0f\r\n",m_DP5_Status.RealTime);        //RealTime
00253         strConfig += strTemp;
00254 
00255         if (m_DP5_Status.DEVICE_ID == dppMCA8000D) {
00256                 strTemp = strfn.Format("Live Time: %.0f\r\n",m_DP5_Status.LiveTime);        //RealTime
00257                 strConfig += strTemp;
00258         }
00259 
00260    if ((m_DP5_Status.DEVICE_ID != dppDP5G) && (m_DP5_Status.DEVICE_ID != dppTB5) && (m_DP5_Status.DEVICE_ID != dppMCA8000D)) {
00261         strTemp = strfn.Format("Detector Temp: %.0fK\r\n",m_DP5_Status.DET_TEMP);               //"##0°C") ' round to nearest degree
00262                 strConfig += strTemp;
00263                 strTemp = strfn.Format("Detector HV: %.0fV\r\n",m_DP5_Status.HV);
00264                 strConfig += strTemp;
00265                 strTemp = strfn.Format("Board Temp: %d°C\r\n",(int)m_DP5_Status.DP5_TEMP);
00266                 strConfig += strTemp;
00267         } else if ((m_DP5_Status.DEVICE_ID == dppDP5G) || (m_DP5_Status.DEVICE_ID == dppTB5)) {         // GAMMARAD5,TB5
00268                 if (m_DP5_Status.DET_TEMP > 0) {
00269                         strTemp = strfn.Format("Detector Temp: %.1fK\r\n",m_DP5_Status.DET_TEMP);
00270                         strConfig += strTemp;
00271                 } else {
00272                         strConfig += "";
00273                 }
00274                 strTemp = strfn.Format("HV Set: %.0fV\r\n",m_DP5_Status.HV);
00275                 strConfig += strTemp;
00276         } else if (m_DP5_Status.DEVICE_ID == dppMCA8000D) {             // Digital MCA
00277                 strTemp = strfn.Format("Board Temp: %d°C\r\n",(int)m_DP5_Status.DP5_TEMP);
00278                 strConfig += strTemp;
00279         }
00280         if (m_DP5_Status.DEVICE_ID == dppPX5) {
00281                 strTemp = PX5_OptionsString(m_DP5_Status);
00282                 strConfig += strTemp;
00283                 strTemp = strfn.Format("TEC V: %.3fV\r\n",m_DP5_Status.TEC_Voltage);
00284                 strConfig += strTemp;
00285         }
00286         return strConfig;
00287 }
00288 
00289 void CDP5Status::Process_Diagnostics(Packet_In PIN, DiagDataType *dd, int device_type)
00290 {
00291     long idxVal;
00292     string strVal;
00293         double DP5_ADC_Gain[10];  // convert each ADC count to engineering units - values calculated in FORM.LOAD
00294         double PC5_ADC_Gain[3];
00295         double PX5_ADC_Gain[12];
00296     stringex strfn;
00297 
00298     DP5_ADC_Gain[0] = 1.0 / 0.00286;                // 2.86mV/C
00299     DP5_ADC_Gain[1] = 1.0;                          // Vdd mon (out-of-scale)
00300     DP5_ADC_Gain[2] = (30.1 + 20.0) / 20.0;           // PWR
00301     DP5_ADC_Gain[3] = (13.0 + 20.0) / 20.0;            // 3.3V
00302     DP5_ADC_Gain[4] = (4.99 + 20.0) / 20.0;         // 2.5V
00303     DP5_ADC_Gain[5] = 1.0;                          // 1.2V
00304     DP5_ADC_Gain[6] = (35.7 + 20.0) / 20.0;          // 5.5V
00305     DP5_ADC_Gain[7] = (35.7 + 75.0) / 35.7;        // -5.5V (this one is tricky)
00306     DP5_ADC_Gain[8] = 1.0;                          // AN_IN
00307     DP5_ADC_Gain[9] = 1.0;                          // VREF_IN
00308     
00309     PC5_ADC_Gain[0] = 500.0;                        // HV: 1500V/3V
00310     PC5_ADC_Gain[1] = 100.0;                        // TEC: 300K/3V
00311     PC5_ADC_Gain[2] = (20.0 + 10.0) / 10.0;            // +8.5/5V
00312 
00313         //PX5_ADC_Gain[0] = (30.1 + 20.0) / 20.0;          // PWR
00314         PX5_ADC_Gain[0] = (69.8 + 20.0) / 20.0;          // 9V (was originally PWR)
00315     PX5_ADC_Gain[1] = (13.0 + 20.0) / 20.0;            // 3.3V
00316     PX5_ADC_Gain[2] = (4.99 + 20.0) / 20.0;          // 2.5V
00317     PX5_ADC_Gain[3] = 1.0;                         // 1.2V
00318     PX5_ADC_Gain[4] = (30.1 + 20.0) / 20.0;          // 5V
00319     PX5_ADC_Gain[5] = (10.7 + 75.0) / 10.7;         // -5V (this one is tricky)
00320     PX5_ADC_Gain[6] = (64.9 + 20.0) / 20.0;          // +PA
00321     PX5_ADC_Gain[7] = (10.7 + 75) / 10.7;        // -PA
00322     PX5_ADC_Gain[8] = (16.0 + 20.0) / 20.0;            // +TEC
00323     PX5_ADC_Gain[9] = 500.0;                       // HV: 1500V/3V
00324     PX5_ADC_Gain[10] = 100.0;                       // TEC: 300K/3V
00325     PX5_ADC_Gain[11] = 1.0 / 0.00286;               // 2.86mV/C
00326 
00327     dd->Firmware = PIN.DATA[0];
00328     dd->FPGA = PIN.DATA[1];
00329     strVal = "0x0" + FmtHex(PIN.DATA[2], 2) + FmtHex(PIN.DATA[3], 2) + FmtHex(PIN.DATA[4], 2);
00330     dd->SRAMTestData = strtol(strVal.c_str(),NULL,0);
00331     dd->SRAMTestPass = (dd->SRAMTestData == 0xFFFFFF);
00332     dd->TempOffset = PIN.DATA[180] + 256 * (PIN.DATA[180] > 127);  // 8-bit signed value
00333 
00334         if (device_type == devtypeDP5) {
00335                 for(idxVal=0;idxVal<10;idxVal++){
00336                         dd->ADC_V[idxVal] = (float)((((PIN.DATA[5 + idxVal * 2] & 3) * 256) + PIN.DATA[6 + idxVal * 2]) * 2.44 / 1024.0 * DP5_ADC_Gain[idxVal]); // convert counts to engineering units (C or V)
00337                 }
00338                 dd->ADC_V[7] = dd->ADC_V[7] + dd->ADC_V[6] * (float)(1.0 - DP5_ADC_Gain[7]);  // -5.5V is a function of +5.5V
00339                 dd->strTempRaw = strfn.Format("%   #.0f0C", dd->ADC_V[0] - 271.3);
00340                 dd->strTempCal = strfn.Format("%   #.0f0C", (dd->ADC_V[0] - 280.0 + dd->TempOffset));
00341         } else if (device_type == devtypePX5) {
00342         for(idxVal=0;idxVal<11;idxVal++){
00343             dd->ADC_V[idxVal] = (float)((((PIN.DATA[5 + idxVal * 2] & 15) * 256) + PIN.DATA[6 + idxVal * 2]) * 3.0 / 4096.0 * PX5_ADC_Gain[idxVal]);   // convert counts to engineering units (C or V)
00344                 }
00345         dd->ADC_V[11] = (float)((((PIN.DATA[5 + 11 * 2] & 3) * 256) + PIN.DATA[6 + 11 * 2]) * 3.0 / 1024.0 * PX5_ADC_Gain[11]);  // convert counts to engineering units (C or V)
00346         dd->ADC_V[5] = (float)(dd->ADC_V[5] - (3.0 * PX5_ADC_Gain[5]) + 3.0); // -5V uses +3VR
00347         dd->ADC_V[7] = (float)(dd->ADC_V[7] - (3.0 * PX5_ADC_Gain[7]) + 3.0); // -PA uses +3VR
00348                 dd->strTempRaw = strfn.Format("%#.1fC", dd->ADC_V[11] - 271.3);
00349                 dd->strTempCal = strfn.Format("%#.1fC", (dd->ADC_V[11] - 280.0 + dd->TempOffset));
00350         }       
00351         
00352     dd->PC5_PRESENT = false;  // assume no PC5, then check to see if there are any non-zero bytes
00353         for(idxVal=25;idxVal<=38;idxVal++) {
00354                 if (PIN.DATA[idxVal] > 0) {
00355             dd->PC5_PRESENT = true;
00356             break;
00357         }
00358     }
00359 
00360     if (dd->PC5_PRESENT) {
00361                 for(idxVal=0;idxVal<=2;idxVal++) {
00362                         dd->PC5_V[idxVal] = (float)((((PIN.DATA[25 + idxVal * 2] & 15) * 256) + PIN.DATA[26 + idxVal * 2]) * 3.0 / 4096.0 * PC5_ADC_Gain[idxVal]); // convert counts to engineering units (C or V)
00363                 }
00364                 if (PIN.DATA[34] < 128) {
00365                         dd->PC5_SN = (unsigned long)DppUtil.LongWordToDouble(31, PIN.DATA);
00366                 } else {
00367                         dd->PC5_SN = -1; // no PC5 S/N
00368                 }
00369                 if ((PIN.DATA[35] == 255) && (PIN.DATA[36] == 255)) {
00370                         dd->PC5Initialized = false;
00371                         dd->PC5DCAL = 0;
00372                 } else {
00373                         dd->PC5Initialized = true;
00374                         dd->PC5DCAL = (float)(((float)(PIN.DATA[35]) * 256.0 + (float)(PIN.DATA[36])) * 3.0 / 4096.0);
00375                 }
00376                 dd->IsPosHV = ((PIN.DATA[37] & 128) == 128);
00377                 dd->Is8_5VPreAmp = ((PIN.DATA[37] & 64) == 64);
00378                 dd->Sup9VOn = ((PIN.DATA[38] & 8) == 8);
00379                 dd->PreAmpON = ((PIN.DATA[38] & 4) == 4);
00380                 dd->HVOn = ((PIN.DATA[38] & 2) == 2);
00381                 dd->TECOn = ((PIN.DATA[38] & 1) == 1);
00382         } else {
00383         for(idxVal=0;idxVal<=2;idxVal++) {
00384             dd->PC5_V[idxVal] = 0;
00385                 }
00386         dd->PC5_SN = -1; // no PC5 S/N
00387         dd->PC5Initialized = false;
00388         dd->PC5DCAL = 0;
00389         dd->IsPosHV = false;
00390         dd->Is8_5VPreAmp = false;
00391         dd->Sup9VOn = false;
00392         dd->PreAmpON = false;
00393         dd->HVOn = false;
00394         dd->TECOn = false;
00395     }
00396         for(idxVal=0;idxVal<=191;idxVal++) {
00397         dd->DiagData[idxVal] = PIN.DATA[idxVal + 39];
00398     }
00399         //string cstrData;
00400         //cstrData = DisplayBufferArray(PIN.DATA, 256);
00401         //SaveStringDataToFile(cstrData);
00402 }
00403 
00404 string CDP5Status::DiagnosticsToString(DiagDataType dd, int device_type)
00405 {
00406     long idxVal;
00407         string cstrVal;
00408     string strDiag;
00409         stringex strfn;
00410     
00411     strDiag = "Firmware: " + VersionToStr(dd.Firmware) + "\r\n";
00412     strDiag += "FPGA: " + VersionToStr(dd.FPGA) + "\r\n";
00413     strDiag += "SRAM Test: ";
00414     if (dd.SRAMTestPass) {
00415         strDiag += "PASS\r\n";
00416     } else {
00417         strDiag += "ERROR @ 0x" + FmtHex(dd.SRAMTestData, 6) + "\r\n";
00418     }
00419 
00420         if (device_type == devtypeDP5) {
00421                 strDiag += "DP5 Temp (raw): " + dd.strTempRaw + "\r\n";
00422                 strDiag += "DP5 Temp (cal'd): " + dd.strTempCal + "\r\n";
00423                 strDiag += "PWR: " + FmtPc5Pwr(dd.ADC_V[2]) + "\r\n";
00424                 strDiag += "3.3V: " + FmtPc5Pwr(dd.ADC_V[3]) + "\r\n";
00425                 strDiag += "2.5V: " + FmtPc5Pwr(dd.ADC_V[4]) + "\r\n";
00426                 strDiag += "1.2V: " + FmtPc5Pwr(dd.ADC_V[5]) + "\r\n";
00427                 strDiag += "+5.5V: " + FmtPc5Pwr(dd.ADC_V[6]) + "\r\n";
00428                 strDiag += "-5.5V: " + FmtPc5Pwr(dd.ADC_V[7]) + "\r\n";
00429                 strDiag += "AN_IN: " + FmtPc5Pwr(dd.ADC_V[8]) + "\r\n";
00430                 strDiag += "VREF_IN: " + FmtPc5Pwr(dd.ADC_V[9]) + "\r\n";
00431 
00432                 strDiag += "\r\n";
00433                 if (dd.PC5_PRESENT) {
00434                         strDiag += "PC5: Present\r\n";
00435                         cstrVal = strfn.Format("%dV",(int)(dd.PC5_V[0]));
00436                         strDiag += "HV: " + cstrVal + "\r\n";
00437                         cstrVal = strfn.Format("%#.1fK",dd.PC5_V[1]);
00438                         strDiag += "Detector Temp: " + cstrVal + "\r\n";
00439                         strDiag += "+8.5/5V: " + FmtPc5Pwr(dd.PC5_V[2]) + "\r\n";
00440                         if (dd.PC5_SN > -1) {
00441                                 strDiag += "PC5 S/N: " + FmtLng(dd.PC5_SN) + "\r\n";
00442                         } else {
00443                                 strDiag += "PC5 S/N: none\r\n";
00444                         }
00445                         if (dd.PC5Initialized) {
00446                                 strDiag += "PC5 DCAL: " + FmtPc5Pwr(dd.PC5DCAL) + "\r\n";
00447                         } else {
00448                                 strDiag += "PC5 DCAL: Uninitialized\r\n";
00449                         }
00450                         strDiag += "PC5 Flavor: ";
00451                         strDiag += IsAorB(dd.IsPosHV, "+HV, ", "-HV, ");
00452                         strDiag += IsAorB(dd.Is8_5VPreAmp, "8.5V preamp", "5V preamp") + "\r\n";
00453                         strDiag += "PC5 Supplies:\r\n";
00454                         strDiag += "9V: " + OnOffStr(dd.Sup9VOn) + "\r\n";
00455                         strDiag += "Preamp: " + OnOffStr(dd.PreAmpON) + "\r\n";
00456                         strDiag += "HV: " + OnOffStr(dd.HVOn) + "\r\n";
00457                         strDiag += "TEC: " + OnOffStr(dd.TECOn) + "\r\n";
00458                 } else {
00459                         strDiag += "PC5: Not Present\r\n";
00460                 }
00461         } else if (device_type == devtypePX5) {
00462                 strDiag += "PX5 Temp (raw): " + dd.strTempRaw + "\r\n";
00463                 strDiag += "PX5 Temp (cal'd): " + dd.strTempCal + "\r\n";
00464                 //strDiag += "PWR: " + FmtPc5Pwr(dd.ADC_V[0]) + "\r\n";
00465                 strDiag += "9V: " + FmtPc5Pwr(dd.ADC_V[0]) + "\r\n";
00466                 strDiag += "3.3V: " + FmtPc5Pwr(dd.ADC_V[1]) + "\r\n";
00467                 strDiag += "2.5V: " + FmtPc5Pwr(dd.ADC_V[2]) + "\r\n";
00468                 strDiag += "1.2V: " + FmtPc5Pwr(dd.ADC_V[3]) + "\r\n";
00469                 strDiag += "+5V: " + FmtPc5Pwr(dd.ADC_V[4]) + "\r\n";
00470                 strDiag += "-5V: " + FmtPc5Pwr(dd.ADC_V[5]) + "\r\n";
00471                 strDiag += "+PA: " + FmtPc5Pwr(dd.ADC_V[6]) + "\r\n";
00472                 strDiag += "-PA: " + FmtPc5Pwr(dd.ADC_V[7]) + "\r\n";
00473                 strDiag += "TEC: " + FmtPc5Pwr(dd.ADC_V[8]) + "\r\n";
00474                 strDiag += "ABS(HV): " + FmtHvPwr(dd.ADC_V[9]) + "\r\n";
00475                 strDiag += "DET_TEMP: " + FmtPc5Temp(dd.ADC_V[10]) + "\r\n";
00476         }
00477 
00478     strDiag += "\r\nDiagnostic Data\r\n";
00479     strDiag += "---------------\r\n";
00480         for(idxVal=0;idxVal<=191;idxVal++) {
00481         if ((idxVal % 8) == 0) { 
00482                         strDiag += FmtHex(idxVal, 2) + ":";
00483                 }
00484         strDiag += FmtHex(dd.DiagData[idxVal], 2) + " ";
00485         if ((idxVal % 8) == 7) { 
00486                         strDiag += "\r\n";
00487                 }
00488     }
00489     return (strDiag);
00490 }
00491 
00492 string CDP5Status::DiagStrPX5Option(DiagDataType dd, int device_type)
00493 {
00494     long idxVal;
00495         string cstrVal;
00496     string strDiag;
00497         stringex strfn;
00498    
00499     strDiag = "Firmware: " + VersionToStr(dd.Firmware) + "\r\n";
00500     strDiag += "FPGA: " + VersionToStr(dd.FPGA) + "\r\n";
00501     strDiag += "SRAM Test: ";
00502     if (dd.SRAMTestPass) {
00503         strDiag += "PASS\r\n";
00504     } else {
00505         strDiag += "ERROR @ 0x" + FmtHex(dd.SRAMTestData, 6) + "\r\n";
00506     }
00507 
00508         if (device_type == devtypePX5) {
00509                 strDiag += "PX5 Temp (raw): " + dd.strTempRaw + "\r\n";
00510                 strDiag += "PX5 Temp (cal'd): " + dd.strTempCal + "\r\n";
00511                 strDiag += "9V: " + FmtPc5Pwr(dd.ADC_V[0]) + "\r\n";
00512                 strDiag += "3.3V: " + FmtPc5Pwr(dd.ADC_V[1]) + "\r\n";
00513                 strDiag += "2.5V: " + FmtPc5Pwr(dd.ADC_V[2]) + "\r\n";
00514                 strDiag += "TDET: " + FmtPc5Pwr(dd.ADC_V[3]) + "\r\n";
00515                 strDiag += "+5V: " + FmtPc5Pwr(dd.ADC_V[4]) + "\r\n";
00516                 strDiag += "-5V: " + FmtPc5Pwr(dd.ADC_V[5]) + "\r\n";
00517                 strDiag += "+PA: " + FmtPc5Pwr(dd.ADC_V[6]) + "\r\n";
00518                 strDiag += "-PA: " + FmtPc5Pwr(dd.ADC_V[7]) + "\r\n";
00519                 strDiag += "TEC: " + FmtPc5Pwr(dd.ADC_V[8]) + "\r\n";
00520                 strDiag += "ABS(HV): " + FmtHvPwr(dd.ADC_V[9]) + "\r\n";
00521                 strDiag += "DET_TEMP: " + FmtPc5Temp(dd.ADC_V[10]) + "\r\n";
00522         }
00523 
00524     strDiag += "\r\nDiagnostic Data\r\n";
00525     strDiag += "---------------\r\n";
00526         for(idxVal=0;idxVal<=191;idxVal++) {
00527         if ((idxVal % 8) == 0) { 
00528                         strDiag += FmtHex(idxVal, 2) + ":";
00529                 }
00530         strDiag += FmtHex(dd.DiagData[idxVal], 2) + " ";
00531         if ((idxVal % 8) == 7) { 
00532                         strDiag += "\r\n";
00533                 }
00534     }
00535     return (strDiag);
00536 }
00537 
00538 string CDP5Status::FmtHvPwr(float fVal) 
00539 {
00540         string cstrVal;
00541         stringex strfn;
00542         cstrVal = strfn.Format("%#.1fV", fVal); // "#.##0V"
00543         return cstrVal;
00544 }
00545 
00546 string CDP5Status::FmtPc5Pwr(float fVal) 
00547 {
00548         string cstrVal;
00549         stringex strfn;
00550         cstrVal = strfn.Format("%#.3fV", fVal); // "#.##0V"
00551         return cstrVal;
00552 }
00553 
00554 string CDP5Status::FmtPc5Temp(float fVal) 
00555 {
00556         string cstrVal;
00557         stringex strfn;
00558         cstrVal = strfn.Format("%#.1fK", fVal); // "#.##0V"
00559         return cstrVal;
00560 }
00561 
00562 string CDP5Status::FmtHex(long FmtHex, long HexDig) 
00563 {
00564         string cstrHex;
00565         string cstrFmt;
00566         stringex strfn;
00567         cstrFmt = strfn.Format("%d",HexDig);            // max size of 0 pad
00568         cstrFmt = "%0" + cstrFmt + "X";         // string format specifier
00569         cstrHex = strfn.Format(cstrFmt.c_str(), FmtHex);        // create padded string
00570         return cstrHex;
00571 }
00572 
00573 string CDP5Status::FmtLng(long lVal) 
00574 {
00575         string cstrVal;
00576         stringex strfn;
00577         cstrVal = strfn.Format("%d", lVal);
00578         return cstrVal;
00579 }
00580 
00581 string CDP5Status::VersionToStr(unsigned char bVersion)
00582 {
00583         string cstrVerMajor;
00584         string cstrVerMinor;
00585         string cstrVer;
00586         stringex strfn;
00587         cstrVerMajor = strfn.Format("%d",((bVersion & 0xF0) / 16));
00588         cstrVerMinor = strfn.Format("%02d",(bVersion & 0x0F));
00589         cstrVer = cstrVerMajor + "." + cstrVerMinor;
00590         return (cstrVer);
00591 }
00592 
00593 string CDP5Status::OnOffStr(bool bOn)
00594 {
00595     if (bOn) {
00596         return("ON");
00597     } else {
00598         return("OFF");
00599     }
00600 }
00601 
00602 string CDP5Status::IsAorB(bool bIsA, string strA, string strB)
00603 {
00604     if (bIsA) {
00605         return(strA);
00606     } else {
00607         return(strB);
00608     }
00609 }
00610 
00611 string CDP5Status::GetDeviceNameFromVal(int DeviceTypeVal) 
00612 {
00613     string cstrDeviceType;
00614         switch(DeviceTypeVal) {
00615                 case 0:
00616             cstrDeviceType = "DP5";
00617                         break;
00618                 case 1:
00619             cstrDeviceType = "PX5";
00620                         break;
00621                 case 2:
00622             cstrDeviceType = "DP5G";
00623                         break;
00624                 case 3:
00625             cstrDeviceType = "MCA8000D";
00626                         break;
00627                 case 4:
00628             cstrDeviceType = "TB5";
00629                         break;
00630                 default:           //if unknown set to DP5
00631             cstrDeviceType = "DP5";
00632                         break;
00633         }
00634     return cstrDeviceType;
00635 }
00636 
00637 string CDP5Status::DisplayBufferArray(unsigned char buffer[], unsigned long bufSizeIn)
00638 {
00639     unsigned long i;
00640         string cstrVal("");
00641         string cstrMsg("");
00642         stringex strfn;
00643         for(i=0;i<bufSizeIn;i++) {
00644                 cstrVal = strfn.Format("%.2X ",buffer[i]);
00645                 cstrMsg += cstrVal;
00646                 //if (((i+1) % 16) == 0 ) { 
00647                 //      cstrMsg += "\r\n";
00648                 //} else 
00649                 if (((i+1) % 8) == 0 ) {
00650                 //      cstrMsg += "   ";
00651                         //cstrMsg += "\r\n";
00652                         cstrMsg += "\n";
00653                 }
00654         }
00655         //cstrMsg += "\n";
00656         return cstrMsg;
00657 }
00658 
00659 void CDP5Status::SaveStringDataToFile(string strData)
00660 {
00661         FILE  *out;
00662         string strFilename;
00663         string strError;
00664         stringex strfn;
00665 
00666         strFilename = "vcDP5_Data.txt";
00667 
00668         if ( (out = fopen(strFilename.c_str(),"w")) == (FILE *) NULL)
00669                 strError = strfn.Format("Couldn't open %s for writing.\n", strFilename.c_str());
00670         else
00671         {
00672                 fprintf(out,"%s\n",strData.c_str());
00673         }
00674         fclose(out);
00675 }
00676 
00677 
00678 
00679 
00680 
00681 
00682 
00683 
00684 
00685 
00686 
00687 
00688