FedmIscReport_ReaderInfo.cpp
Go to the documentation of this file.
00001 /*-------------------------------------------------------
00002 |                                                       |
00003 |                               FedmIscReport_ReaderInfo.cpp            |
00004 |                                                       |
00005 ---------------------------------------------------------
00006 
00007 Copyright © 2009-2013   FEIG ELECTRONIC GmbH, All Rights Reserved.
00008                                                 Lange Strasse 4
00009                                                 D-35781 Weilburg
00010                                                 Federal Republic of Germany
00011                                                 phone    : +49 6471 31090
00012                                                 fax      : +49 6471 310999
00013                                                 e-mail   : obid-support@feig.de
00014                                                 Internet : http://www.feig.de
00015                                         
00016 Author                  :       Markus Hultsch
00017 Begin                   :       17.06.2009
00018 
00019 Version                 :       04.06.08 / 13.10.2014 / M. Hultsch
00020                                                 - additional LAN link information with mode=0x50
00021 
00022                                                 04.05.05 / 29.11.2013 / M. Hultsch
00023                                                 - new mode 0x09 for WLAN-Firmware
00024 
00025                                                 04.05.03 / 15.07.2013 / M. Hultsch
00026                                                 - OBID myAXXESS onTop added
00027 
00028                                                 04.02.06 / 23.07.2012 / M. Hultsch
00029                                                 - new mode 0x08 (with firmware supported tag drivers)
00030 
00031                                                 04.00.09 / 01.02.2012 / M. Hultsch
00032                                                 - mode 0x04: modification for CPR-Reader
00033 
00034                                                 03.03.00 / 01.02.2011 / M. Hultsch
00035                                                 - ID ISC.LR2500-A added
00036 
00037                                                 03.02.04 / 17.08.2010 / M. Hultsch
00038                                                 - ID CPR30.xx added
00039 
00040                                                 03.01.01 / 23.02.2010 / M. Hultsch
00041                                                 - new mode: 0x61
00042 
00043                                                 03.00.19 / 12.01.2010 / M. Hultsch
00044                                                 - new modes: 0x07, 0x12
00045 
00046                                                 03.00.14 / 15.10.2009 / M. Hultsch
00047                                                 - mode 0x01 with additional data
00048 
00049                                                 03.00.13 / 13.10.2009 / M. Hultsch
00050                                                 - ID MAX50.xx added
00051 
00052                                                 03.00.12 / 22.09.2009 / M. Hultsch
00053 
00054 Operation Systems       :       independent
00055 
00056 Function                        :       report class for [0x66] Reader Info
00057 
00058 
00059 Trademarks:
00060 -----------
00061 OBID®, OBID i-scan® and OBID myAXXESS® are registered Trademarks of FEIG ELECTRONIC GmbH
00062 Other Trademarks: see FEDM.h
00063 */
00064 
00065 #include "FedmIscReport_ReaderInfo.h"
00066 #include "../FEDM_ISCReader.h"
00067 #include "../FEDM_ISCReaderID.h"
00068 #include "../../FEDM_Functions.h"
00069 #if !defined(_FEDM_NO_PD_SUPPORT)
00070         #include "../peripheral_devices/FedmIscPeripheralDevice.h"
00071 #endif
00072 
00073 
00074 FedmIscReport_ReaderInfo::FedmIscReport_ReaderInfo(FEDM_ISCReader* pReader)
00075 {
00076         m_pReader = pReader;
00077 }
00078 
00079 FedmIscReport_ReaderInfo::~FedmIscReport_ReaderInfo()
00080 {
00081 }
00082 
00083 string FedmIscReport_ReaderInfo::BuildReport(unsigned char ucMode)
00084 {
00085 #if _MSC_VER <= 1200
00086         m_sReport.erase(m_sReport.begin(), m_sReport.end());
00087 #else
00088         m_sReport.clear();
00089 #endif
00090         BuildReport(ucMode, m_sReport);
00091         return m_sReport;
00092 }
00093 
00094 int FedmIscReport_ReaderInfo::BuildReport(unsigned char ucMode, string& sReport)
00095 {
00096         if(m_pReader == NULL)
00097                 return FEDM_ERROR_NULL_POINTER;
00098 
00099         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00100 
00101         switch(ucMode)
00102         {
00103         case 0x00:
00104                 if(pInfo->bIsMode0x00Read)
00105                         Add0x00InfoText(sReport);               // [0x65] version info of µC
00106                 break;
00107 
00108         case 0x01:
00109                 if(pInfo->bIsMode0x01Read)
00110                         Add0x01InfoText(sReport);               // version info of AC-Controller
00111                 break;
00112         
00113         case 0x02:
00114                 if(pInfo->bIsMode0x02Read)
00115                         Add0x02InfoText(sReport);               // version info of USB-Controller
00116                 break;
00117         
00118         case 0x03:
00119                 if(pInfo->bIsMode0x03Read)
00120                         Add0x03InfoText(sReport);               // version info of RF-Decoder
00121                 break;
00122         
00123         case 0x04:
00124                 if(pInfo->bIsMode0x04Read)
00125                         Add0x04InfoText(sReport);               // version info of additional Reader Functions
00126                 break;
00127         
00128         case 0x05:
00129                 if(pInfo->bIsMode0x05Read)
00130                         Add0x05InfoText(sReport);               // version info of RFC Bootloader
00131                 break;
00132         
00133         case 0x06:
00134                 if(pInfo->bIsMode0x06Read)
00135                         Add0x06InfoText(sReport);               // information from keyboard unit
00136                 break;
00137         
00138         case 0x07:
00139                 if(pInfo->bIsMode0x07Read)
00140                         Add0x07InfoText(sReport);               // information from CPRIO unit
00141                 break;
00142         
00143         case 0x08:
00144                 if(pInfo->bIsMode0x08Read)
00145                         Add0x08InfoText(sReport);               // version info of Hardware
00146                 break;
00147         
00148         case 0x09:
00149                 if(pInfo->bIsMode0x09Read)
00150                         Add0x09InfoText(sReport);               // version info of WLAN-Module
00151                 break;
00152         
00153         case 0x10:
00154                 if(pInfo->bIsMode0x10Read)
00155                         Add0x10InfoText(sReport);               // version info of Hardware
00156                 break;
00157         
00158         case 0x11:
00159                 if(pInfo->bIsMode0x11Read)
00160                         Add0x11InfoText(sReport);               // SAM info
00161                 break;
00162         
00163         case 0x12:
00164                 if(pInfo->bIsMode0x12Read)
00165                         Add0x12InfoText(sReport);               // CPU infor of RFC
00166                 break;
00167         
00168         case 0x40:
00169                 if(pInfo->bIsMode0x40Read)
00170                         Add0x40InfoText(sReport);               // version info of Hardware
00171                 break;
00172         
00173         case 0x41:
00174                 if(pInfo->bIsMode0x41Read)
00175                         Add0x41InfoText(sReport);               // version info of Hardware
00176                 break;
00177         
00178         case 0x50:
00179                 if(pInfo->bIsMode0x50Read)
00180                         Add0x50InfoText(sReport);               // LAN: MAC
00181                 break;
00182         
00183         case 0x51:
00184                 if(pInfo->bIsMode0x51Read)
00185                         Add0x51InfoText(sReport);               // LAN: IP-Address
00186                 break;
00187         
00188         case 0x52:
00189                 if(pInfo->bIsMode0x52Read)
00190                         Add0x52InfoText(sReport);               // LAN: Netmask
00191                 break;
00192         
00193         case 0x53:
00194                 if(pInfo->bIsMode0x53Read)
00195                         Add0x53InfoText(sReport);               // LAN: Gateway-Address
00196                 break;
00197         
00198         case 0x54:
00199                 if(pInfo->bIsMode0x54Read)
00200                         Add0x54InfoText(sReport);               // WLAN: MAC
00201                 break;
00202         
00203         case 0x55:
00204                 if(pInfo->bIsMode0x55Read)
00205                         Add0x55InfoText(sReport);               // WLAN: IP-Address
00206                 break;
00207         
00208         case 0x56:
00209                 if(pInfo->bIsMode0x56Read)
00210                         Add0x56InfoText(sReport);               // WLAN: Netmask
00211                 break;
00212         
00213         case 0x57:
00214                 if(pInfo->bIsMode0x57Read)
00215                         Add0x57InfoText(sReport);               // WLAN: Gateway-Address
00216                 break;
00217         
00218         case 0x60:
00219                 if(pInfo->bIsMode0x60Read)
00220                         Add0x60InfoText(sReport);               // version info of Hardware
00221                 break;
00222         
00223         case 0x61:
00224                 if(pInfo->bIsMode0x61Read)
00225                         Add0x61InfoText(sReport);               // external peripheral devices information
00226                 break;
00227         
00228         case 0x80:
00229                 if(pInfo->bIsMode0x80Read)
00230                         Add0x80InfoText(sReport);               // device info
00231                 break;
00232         
00233         case 0xFF:
00234                 AddAllInfoText(sReport);
00235                 break;
00236 
00237         default:
00238                 break;
00239         }
00240 
00241         return FEDM_OK;
00242 }
00243 
00244 
00245 // version info like [0x65] Software Version
00246 void FedmIscReport_ReaderInfo::Add0x00InfoText(string& sReport, bool bSingle)
00247 {
00248         char cBuffer[64];
00249         unsigned char ucSWRevHigh = 0;
00250         unsigned char ucSWRevLow = 0;
00251         unsigned char ucHWType = 0;
00252         unsigned char ucSWType = 0;
00253         unsigned char ucDRev = 0;
00254         unsigned char ucTrType[2];
00255         unsigned char ucTrTypeUhf[2];
00256         unsigned int uiRxBufLen = 0;
00257         unsigned int uiTxBufLen = 0;
00258         unsigned char ucReaderClassGen = 0;
00259         unsigned char ucReaderTypeOfClass = 0;
00260         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00261 
00262         if(bSingle)
00263         {
00264                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_D_REV, &ucDRev);
00265                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_SW_REV_HIGH, &ucSWRevHigh);
00266                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_SW_REV_LOW, &ucSWRevLow);
00267                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_HW_TYPE, &ucHWType);
00268                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_SW_TYPE, &ucSWType); // reader type, if Bit 7 = 0 or reader class, if Bit 7 = 1
00269                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_TR_TYPE, ucTrType, 2);
00270                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_RX_BUF, &uiRxBufLen);
00271                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_TX_BUF, &uiTxBufLen);
00272                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_TR_TYPE_UHF, ucTrTypeUhf, 2);
00273                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_READER_CLASS_GEN, &ucReaderClassGen); // only valid, if ucSWType contains a reader class
00274                 m_pReader->GetData(FEDM_ISC_TMP_SOFTVER_READER_TYPE_OF_CLASS, &ucReaderTypeOfClass); // only valid, if ucSWType contains a reader class
00275         }
00276         else
00277         {
00278                 ucSWRevHigh     = pInfo->ucRfcSwVer[0];
00279                 ucSWRevLow              = pInfo->ucRfcSwVer[1];
00280                 ucDRev                  = pInfo->ucRfcDevVer;
00281                 ucHWType                = pInfo->ucRfcHwType;
00282                 ucSWType                = pInfo->ucReaderType; // reader type, if Bit 7 = 0 or reader class, if Bit 7 = 1
00283                 ucTrType[0]             = pInfo->ucRfcTrType[0];
00284                 ucTrType[1]             = pInfo->ucRfcTrType[1];
00285                 uiRxBufLen              = (pInfo->ucRfcRxBufferSize[0]<<8) + pInfo->ucRfcRxBufferSize[1];
00286                 uiTxBufLen              = (pInfo->ucRfcTxBufferSize[0]<<8) + pInfo->ucRfcTxBufferSize[1];
00287                 ucTrTypeUhf[0]  = pInfo->ucRfcUhfTrType[0];
00288                 ucTrTypeUhf[1]  = pInfo->ucRfcUhfTrType[1];
00289                 ucReaderClassGen        = pInfo->ucReaderClassGen; // only valid, if ucSWType contains a reader class
00290                 ucReaderTypeOfClass     = pInfo->ucReaderTypeOfClass; // only valid, if ucSWType contains a reader class
00291         }
00292 
00293 //      sReport += "\n\n";
00294 
00295         sReport += "Firmware Version of RF Communication Controller:";
00296         sReport += "\r\n";
00297         if(ucSWType==FEDM_ISC_TYPE_ISCLR200)
00298                 sprintf(cBuffer, "%02d.%02d.%02d", (ucSWRevHigh&0x0F), ucSWRevLow, ucDRev);
00299         else
00300                 sprintf(cBuffer, "%02d.%02d.%02d", ucSWRevHigh, ucSWRevLow, ucDRev);
00301 
00302         sReport += "\tSoftware Revision:.....";
00303         sReport += cBuffer;
00304         if(pInfo->ucReaderType == FEDM_ISC_TYPE_ISCLRU3000)
00305         {
00306                 if(ucSWRevHigh < 2)
00307                 {
00308                         sReport+= " (unsupported)";
00309                 }
00310         }
00311         sReport += "\r\n";
00312         sprintf(cBuffer, "0x%02X", ucHWType);
00313         sReport += "\tHardware Type:.........";
00314         sReport += cBuffer;
00315         sReport += "\r\n";
00316 
00317         switch(ucSWType)
00318         {
00319         case FEDM_ISC_TYPE_CPRM02:
00320                 if(ucHWType & 0x01)
00321                         sReport += "\t   - with SAM socket\r\n";
00322                 else
00323                         sReport += "\t   - without SAM socket\r\n";
00324 
00325                 if( (ucHWType & 0x03) == 0x03)
00326                         sReport += "\t   - SAM inserted\r\n";
00327                 else if( (ucHWType & 0x01) && !(ucHWType & 0x02) )
00328                         sReport += "\t   - SAM not inserted\r\n";
00329 
00330                 if( (ucHWType & 0xC0) == 0x00)
00331                         sReport += "\t   - Model is -CA\r\n";
00332                 else if( (ucHWType & 0xC0) == 0x40 )
00333                         sReport += "\t   - Model is -BA\r\n";
00334                 else if( (ucHWType & 0xC0) == 0x80 )
00335                         sReport += "\t   - Model is -C\r\n";
00336                 else if( (ucHWType & 0xC0) == 0xC0 )
00337                         sReport += "\t   - Model is -B\r\n";
00338 
00339                 break;
00340 
00341         case FEDM_ISC_TYPE_CPR02:
00342         case FEDM_ISC_TYPE_CPR04_U:
00343                 if(ucHWType & 0x01)
00344                         sReport += "\t   - with SAM socket\r\n";
00345                 else
00346                         sReport += "\t   - without SAM socket\r\n";
00347 
00348                 if( (ucHWType & 0x03) == 0x03)
00349                         sReport += "\t   - SAM inserted\r\n";
00350                 else if( (ucHWType & 0x01) && !(ucHWType & 0x02) )
00351                         sReport += "\t   - SAM not inserted\r\n";
00352 
00353                 break;
00354 
00355         case FEDM_ISC_TYPE_CPR40_XX_U:
00356         case FEDM_ISC_TYPE_CPR40_XX:
00357                 if(ucHWType & 0x01)
00358                         sReport += "\t   - with SAM sockets\r\n";
00359                 else
00360                         sReport += "\t   - without SAM sockets\r\n";
00361 
00362                 if( (ucHWType & 0x03) == 0x03)
00363                         sReport += "\t   - SAM inserted in socket 1\r\n";
00364                 else if( (ucHWType & 0x01) && !(ucHWType & 0x02) )
00365                         sReport += "\t   - SAM socket 1 is not used\r\n";
00366 
00367                 if( (ucHWType & 0x11) == 0x11)
00368                         sReport += "\t   - SAM inserted in socket 2\r\n";
00369                 else if( (ucHWType & 0x01) && !(ucHWType & 0x02) )
00370                         sReport += "\t   - SAM socket 2 is not used\r\n";
00371 
00372                 break;
00373         }
00374 
00375         if(ucSWType & 0x80)
00376         {
00377                 // rfu
00378                 sReport += "\tReader Class:..........";
00379                 sprintf(cBuffer, "%02d", ucSWType);
00380                 sReport += cBuffer;
00381                 sReport += "\tReader Class Gen:......";
00382                 sprintf(cBuffer, "%02d", ucReaderClassGen);
00383                 sReport += cBuffer;
00384                 sReport += "\tReader Type:...........";
00385                 sprintf(cBuffer, "%02d", ucReaderTypeOfClass);
00386                 sReport += cBuffer;
00387         }
00388         else
00389         {
00390                 sReport += "\tReader Type:...........";
00391                 sprintf(cBuffer, "%02d", ucSWType);
00392                 sReport += cBuffer;
00393         }
00394         sReport += " (";
00395         sReport += m_pReader->GetReaderName();
00396         sReport += ")";
00397         sReport += "\r\n";
00398         if(ucSWType == FEDM_ISC_TYPE_ISCPRHD102)
00399         {
00400                 sprintf(cBuffer, "0x%02X 0x%02X", ucTrType[0], ucTrType[1]);
00401                 sReport += "\tHF  Transponder Types:.";
00402                 sReport += cBuffer;
00403                 sReport += "\r\n";
00404 
00405                 sprintf(cBuffer, "0x%02X 0x%02X", ucTrTypeUhf[0], ucTrTypeUhf[1]);
00406                 sReport += "\tUHF Transponder Types:.";
00407                 sReport += cBuffer;
00408                 sReport += "\r\n";
00409         }
00410         else if(ucSWType == FEDM_ISC_TYPE_CPR46_XX || ucSWType == FEDM_ISC_TYPE_CPR47_XX || ucSWType == FEDM_ISC_TYPE_MAX_ONTOP)
00411         {
00412                 // supported tag drivers are displayed with mode 0x08
00413         }
00414         else
00415         {
00416                 sprintf(cBuffer, "0x%02X 0x%02X", ucTrType[0], ucTrType[1]);
00417                 sReport += "\tTransponder Types:.....";
00418                 sReport += cBuffer;
00419                 sReport += "\r\n";
00420         }
00421 
00422         sprintf(cBuffer, "%05d", uiRxBufLen);
00423         sReport += "\tMax. Rx buffer size:...";
00424         sReport += cBuffer;
00425         sReport += "\r\n";
00426         sprintf(cBuffer, "%05d", uiTxBufLen);
00427         sReport += "\tMax. Tx buffer size:...";
00428         sReport += cBuffer;
00429         sReport += "\r\n";
00430 }
00431 
00432 
00433 void FedmIscReport_ReaderInfo::Add0x01InfoText(string& sReport, bool bSingle)
00434 {
00435         char cBuffer[64];
00436         unsigned char ucSWMajor = 0;
00437         unsigned char ucSWMinor = 0;
00438         unsigned char ucSWDev = 0;
00439         unsigned char ucHWType = 0;
00440         unsigned char ucEmbAppSWMajor = 0;
00441         unsigned char ucEmbAppSWMinor = 0;
00442         unsigned char ucEmbAppSWDev = 0;
00443         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00444 
00445         if(bSingle)
00446         {
00447                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MAJOR, &ucSWMajor);
00448                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MINOR, &ucSWMinor);
00449                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_DEV, &ucSWDev);
00450                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_HW_TYPE, &ucHWType);
00451                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MAJOR_EMB_APP, &ucEmbAppSWMajor);
00452                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MINOR_EMB_APP, &ucEmbAppSWMinor);
00453                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_DEV_EMB_APP, &ucEmbAppSWDev);
00454         }
00455         else
00456         {
00457                 ucSWMajor       = pInfo->ucAccSwVer[0];
00458                 ucSWMinor       = pInfo->ucAccSwVer[1];
00459                 ucSWDev         = pInfo->ucAccDevVer;
00460                 ucHWType        = pInfo->ucAccHwType;
00461                 ucEmbAppSWMajor = pInfo->ucAccEmbAppSwVer[0];
00462                 ucEmbAppSWMinor = pInfo->ucAccEmbAppSwVer[1];
00463                 ucEmbAppSWDev   = pInfo->ucAccEmbAppDevVer;
00464         }
00465 
00466 //      sReport += "\n\n";
00467         sReport += "Firmware Version of Application Communication Controller:";
00468         sReport += "\r\n";
00469         sReport += "\tSoftware Revision:.....";
00470         sprintf(cBuffer, "%02d.%02d.%02d", ucSWMajor, ucSWMinor, ucSWDev);
00471         sReport += cBuffer;
00472         if(pInfo->ucReaderType == FEDM_ISC_TYPE_ISCLRU3000)
00473         {
00474                 if(ucSWMajor < 2)
00475                 {
00476                         sReport+= " (unsupported)";
00477                 }
00478         }
00479         sReport += "\r\n";
00480         sprintf(cBuffer, "%02d (0x%02X)", ucHWType, ucHWType);
00481         sReport += "\tHardware Type:.........";
00482         sReport += cBuffer;
00483         sReport += "\r\n";
00484         if(ucEmbAppSWMajor != 0 || ucEmbAppSWMinor != 0 || ucEmbAppSWDev != 0)
00485         {
00486                 sReport += "\tSoftware Revision 2:...";
00487                 sprintf(cBuffer, "%02d.%02d.%02d", ucEmbAppSWMajor, ucEmbAppSWMinor, ucEmbAppSWDev);
00488                 sReport += cBuffer;
00489                 sReport += "\r\n";
00490         }
00491 }
00492 
00493 
00494 // version info for USB controller
00495 void FedmIscReport_ReaderInfo::Add0x02InfoText(string& sReport, bool bSingle)
00496 {
00497         char cBuffer[64];
00498         unsigned char ucSWRevHigh = 0;
00499         unsigned char ucSWRevLow = 0;
00500         unsigned char ucHWType = 0;
00501         unsigned char ucDRev = 0;
00502         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00503 
00504         if(bSingle)
00505         {
00506                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MAJOR, &ucSWRevHigh);
00507                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MINOR, &ucSWRevLow);
00508                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_DEV, &ucDRev);
00509                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_HW_TYPE, &ucHWType);
00510         }
00511         else
00512         {
00513                 ucSWRevHigh = pInfo->ucUsbSwVer[0];
00514                 ucSWRevLow      = pInfo->ucUsbSwVer[1];
00515                 ucDRev          = pInfo->ucUsbDevVer;
00516                 ucHWType        = pInfo->ucUsbHwType;
00517         }
00518 
00519 
00520 //      sReport += "\n\n";
00521         sReport += "Firmware Version of USB-Controller:";
00522         sReport += "\r\n";
00523         sprintf(cBuffer, "%02d.%02d.%02d", ucSWRevHigh, ucSWRevLow, ucDRev);
00524 
00525         sReport += "\tSoftware Revision:.....";
00526         sReport += cBuffer;
00527         sReport += "\r\n";
00528         sprintf(cBuffer, "%02d", ucHWType);
00529         sReport += "\tHardware Type:.........";
00530         sReport += cBuffer;
00531         sReport += "\r\n";
00532 }
00533 
00534 
00535 void FedmIscReport_ReaderInfo::Add0x03InfoText(string& sReport, bool bSingle)
00536 {
00537         char cBuffer[64];
00538         unsigned char ucDecType[32];
00539         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00540         unsigned int uiReaderType = m_pReader->GetReaderType();
00541 
00542         if(bSingle)
00543         {
00544                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucDecType, 11);
00545         }
00546         else
00547         {
00548                 memcpy(ucDecType, &pInfo->ucDecoderType[0], 6);
00549         }
00550 
00551 //      sReport += "\n\n";
00552 
00553         switch(uiReaderType)
00554         {
00555         case FEDM_ISC_TYPE_ISCLR2000:
00556         case FEDM_ISC_TYPE_ISCLR2500_B:
00557         case FEDM_ISC_TYPE_ISCMRU200:
00558         case FEDM_ISC_TYPE_ISCLRU1000:
00559         case FEDM_ISC_TYPE_ISCLRU2000:
00560                 sReport += "Firmware Version of FPGA-Controller:";
00561                 sReport += "\r\n";
00562                 sReport += "\tSoftware Revision:.....";
00563                 sprintf(cBuffer, "%d.%d.%d", ucDecType[0], ucDecType[1], ucDecType[2]);
00564                 sReport += cBuffer;
00565                 sReport += "\r\n";
00566                 sReport += "\tFPGA-Type:.............";
00567                 sprintf(cBuffer, "%d", ucDecType[3]);
00568                 sReport += cBuffer;
00569                 sReport += "\r\n";
00570                 break;
00571 
00572         case FEDM_ISC_TYPE_ISCLR2500_A:
00573         case FEDM_ISC_TYPE_ISCLRU3000:
00574                 sReport += "Firmware Version of FPGA-Controller:";
00575                 sReport += "\r\n";
00576                 sReport += "\tSoftware Revision:.....";
00577                 sprintf(cBuffer, "%d.%d.%c.%d", ucDecType[0], ucDecType[1], ucDecType[2], ucDecType[3]);
00578                 sReport += cBuffer;
00579                 sReport += "\r\n";
00580                 break;
00581 
00582         case FEDM_ISC_TYPE_MAXU1002:
00583         case FEDM_ISC_TYPE_ISCLRU1002:
00584                 sReport += "RF-Decoder information:";
00585                 sReport += "\r\n";
00586                 sprintf(cBuffer, "\t0x%02X-0x%02X-0x%02X-0x%02X",
00587                                         ucDecType[0],
00588                                         ucDecType[1],
00589                                         ucDecType[2],
00590                                         ucDecType[3] );
00591                 sReport += cBuffer;
00592                 sReport += "\r\n";
00593                 break;
00594 
00595         case FEDM_ISC_TYPE_CPRM02:
00596         case FEDM_ISC_TYPE_CPR02:
00597         case FEDM_ISC_TYPE_CPR04_U:
00598                 sReport += "RF-Decoder information:";
00599                 sReport += "\r\n";
00600                 sprintf(cBuffer, "\t0x%02X-0x%02X-0x%02X-0x%02X-0x%02X",
00601                                         ucDecType[0],
00602                                         ucDecType[1],
00603                                         ucDecType[2],
00604                                         ucDecType[3],
00605                                         ucDecType[4] );
00606                 sReport += cBuffer;
00607                 sReport += "\r\n";
00608                 break;
00609 
00610         case FEDM_ISC_TYPE_CPR20_XX:
00611         case FEDM_ISC_TYPE_CPR40_XX_U:
00612         case FEDM_ISC_TYPE_CPR40_XX:
00613         case FEDM_ISC_TYPE_CPR44_XX:
00614         case FEDM_ISC_TYPE_CPR46_XX:
00615         case FEDM_ISC_TYPE_CPR47_XX:
00616         case FEDM_ISC_TYPE_MAX_ONTOP:
00617                 sReport += "RF-Decoder information:";
00618                 sReport += "\r\n";
00619                 sReport += "\tDecoder Information:...";
00620                 sprintf(cBuffer, "0x%02X-0x%02X-0x%02X-0x%02X-0x%02X",
00621                                         ucDecType[0],
00622                                         ucDecType[1],
00623                                         ucDecType[2],
00624                                         ucDecType[3],
00625                                         ucDecType[4] );
00626                 sReport += cBuffer;
00627                 sReport += "\r\n";
00628 
00629                 sReport += "\tSelf Test:.............";
00630                 if(ucDecType[5])
00631                         sReport += "OK";
00632                 else
00633                         sReport += "Not OK";
00634 
00635                 sReport += "\r\n";
00636                 break;
00637         }
00638 
00639 }
00640 
00641 
00642 void FedmIscReport_ReaderInfo::Add0x04InfoText(string& sReport, bool bSingle)
00643 {
00644         int i=0;
00645         char cBuffer[64];
00646         unsigned char ucDecType[32];
00647         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00648         unsigned int uiReaderType = m_pReader->GetReaderType();
00649 
00650         if(bSingle)
00651         {
00652                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucDecType, 11);
00653         }
00654         else
00655         {
00656                 switch(uiReaderType)
00657                 {
00658                 case FEDM_ISC_TYPE_ISCMU02:
00659                 case FEDM_ISC_TYPE_ISCLR2000:
00660                 case FEDM_ISC_TYPE_ISCLR1002:
00661                 case FEDM_ISC_TYPE_MAXU1002:
00662                 case FEDM_ISC_TYPE_ISCLRU1002:
00663                 case FEDM_ISC_TYPE_ISCLRU2000:
00664                 case FEDM_ISC_TYPE_ISCLRU3000:
00665                         ucDecType[0] = pInfo->ucReserved1;
00666                         memcpy(&ucDecType[1], pInfo->ucFwIdentifierB, 10);
00667                         break;
00668 
00669                 case FEDM_ISC_TYPE_CPR20_XX:
00670                 case FEDM_ISC_TYPE_CPR30_XX:
00671                 case FEDM_ISC_TYPE_CPR40_XX_U:
00672                 case FEDM_ISC_TYPE_CPR40_XX:
00673                 case FEDM_ISC_TYPE_CPR44_XX:
00674                 case FEDM_ISC_TYPE_CPR46_XX:
00675                 case FEDM_ISC_TYPE_CPR47_XX:
00676                 case FEDM_ISC_TYPE_CPR50_XX:
00677                 case FEDM_ISC_TYPE_CPR52_XX:
00678                 case FEDM_ISC_TYPE_CPR60_XX:
00679                 // myAXXESS
00680                 case FEDM_ISC_TYPE_MAX50_XX:
00681                 case FEDM_ISC_TYPE_MAX_STANDARD:
00682                 case FEDM_ISC_TYPE_MAX_COMFORT:
00683                 case FEDM_ISC_TYPE_MAX_ONTOP:
00684                         ucDecType[0] = pInfo->ucCprFctTemplate;
00685                         ucDecType[1] = pInfo->ucCprFctList0;
00686                         ucDecType[2] = pInfo->ucCprFctList1;
00687                         ucDecType[3] = pInfo->ucCprFctList2;
00688                         ucDecType[4] = pInfo->ucCprRfu0;
00689                         ucDecType[5] = pInfo->ucCprRfu1;
00690                         ucDecType[6] = pInfo->ucCprRfu2;
00691                         ucDecType[7] = pInfo->ucCprRfu3;
00692                         ucDecType[8] = pInfo->ucCprRfu4;
00693                         memcpy(&ucDecType[9], pInfo->ucFwIdentifierC, 2);
00694                         break;
00695 
00696                 case FEDM_ISC_TYPE_CPRM02:
00697                 case FEDM_ISC_TYPE_CPR02:
00698                 case FEDM_ISC_TYPE_CPR04_U:
00699                         ucDecType[0] = pInfo->ucCprFctTemplate;
00700                         ucDecType[1] = pInfo->ucCprFctList;
00701                         break;
00702 
00703                 default:
00704                         return;
00705                 }
00706         }
00707 
00708         switch(uiReaderType)
00709         {
00710         case FEDM_ISC_TYPE_ISCMU02:
00711                 sReport += "Additional Firmware Functions:";
00712                 sReport += "\r\n\t";
00713                 for(i=0; i<11; i++)
00714                 {
00715                         sprintf(cBuffer, "0x%02X ", ucDecType[i]);
00716                         sReport += cBuffer;
00717                 }
00718                 sReport += "\r\n";
00719 
00720                 switch(ucDecType[10])
00721                 {
00722                 case 0x00:      sReport += "\t   - RFC Standard Firmware\r\n";                  break;
00723                 }
00724                 break;
00725 
00726         case FEDM_ISC_TYPE_ISCLR1002:
00727         case FEDM_ISC_TYPE_MAXU1002:
00728         case FEDM_ISC_TYPE_ISCLRU1002:
00729                 sReport += "Additional Firmware Functions:";
00730                 sReport += "\r\n\t";
00731                 for(i=0; i<11; i++)
00732                 {
00733                         sprintf(cBuffer, "0x%02X ", ucDecType[i]);
00734                         sReport += cBuffer;
00735                 }
00736                 sReport += "\r\n";
00737                 break;
00738 
00739         case FEDM_ISC_TYPE_ISCLR2000:
00740         case FEDM_ISC_TYPE_ISCLRU2000:
00741         case FEDM_ISC_TYPE_ISCLRU3000:
00742 //              sReport += "\n\n";
00743                 sReport += "Additional Firmware Functions:";
00744                 sReport += "\r\n\t";
00745                 for(i=0; i<11; i++)
00746                 {
00747                         sprintf(cBuffer, "0x%02X ", ucDecType[i]);
00748                         sReport += cBuffer;
00749                 }
00750                 sReport += "\r\n";
00751 
00752                 if(ucDecType[1] == 0x80)
00753                 {
00754                         sReport += "\tSpecial Firmware\r\n";
00755                 }
00756                 else
00757                 {
00758                         switch(ucDecType[10])
00759                         {
00760                         case 0x00:      sReport += "\t   - RFC Standard Firmware\r\n";                  break;
00761                         case 0x01:      sReport += "\t   - RFC Firmware for ST Freedom\r\n";    break;
00762                         case 0x02:      sReport += "\t   - RFC Firmware for NXP\r\n";                   break;
00763                         }
00764                 }
00765                 
00766                 switch(ucDecType[2])
00767                 {
00768                 case 0x00:      sReport += "\t   - ACC Standard Firmware\r\n";                          break;
00769                 }
00770                 break;
00771 
00772         case FEDM_ISC_TYPE_CPRM02:
00773         case FEDM_ISC_TYPE_CPR02:
00774         case FEDM_ISC_TYPE_CPR04_U:
00775 //              sReport += "\n\n";
00776                 sReport += "Additional Firmware Functions:";
00777                 sReport += "\r\n";
00778                 sReport += "\tTemplate:..............";
00779                 sprintf(cBuffer, "0x%02X", ucDecType[0]);
00780                 sReport += cBuffer;
00781                 sReport += "\r\n";
00782                 sReport += "\tFunctions:.............";
00783                 sprintf(cBuffer, "0x%02X", ucDecType[1]);
00784                 sReport += cBuffer;
00785                 sReport += "\r\n";
00786                 break;
00787 
00788         case FEDM_ISC_TYPE_CPR20_XX:
00789         case FEDM_ISC_TYPE_CPR30_XX:
00790         case FEDM_ISC_TYPE_CPR40_XX_U:
00791         case FEDM_ISC_TYPE_CPR40_XX:
00792         case FEDM_ISC_TYPE_CPR44_XX:
00793         case FEDM_ISC_TYPE_CPR46_XX:
00794         case FEDM_ISC_TYPE_CPR47_XX:
00795         case FEDM_ISC_TYPE_CPR50_XX:
00796         case FEDM_ISC_TYPE_CPR52_XX:
00797         case FEDM_ISC_TYPE_CPR60_XX:
00798         // myAXXESS
00799         case FEDM_ISC_TYPE_MAX50_XX:
00800         case FEDM_ISC_TYPE_MAX_STANDARD:
00801         case FEDM_ISC_TYPE_MAX_COMFORT:
00802         case FEDM_ISC_TYPE_MAX_ONTOP:
00803                 sReport += "Additional Firmware Functions:";
00804                 sReport += "\r\n";
00805                 sReport += "\tTemplate:..............";
00806                 sprintf(cBuffer, "0x%02X", ucDecType[0]);
00807                 sReport += cBuffer;
00808                 sReport += "\r\n";
00809                 sReport += "\tFunctions:.............";
00810                 sprintf(cBuffer, "0x%02X 0x%02X 0x%02X", ucDecType[1], ucDecType[2], ucDecType[3]);
00811                 sReport += cBuffer;
00812                 if(ucDecType[1]&0x01)
00813                 {
00814                         sReport += "\r\n";
00815                         sReport += "\t   - with support for T=CL";
00816                 }
00817                 if(ucDecType[1]&0x02)
00818                 {
00819                         sReport += "\r\n";
00820                         sReport += "\t   - with support for MAD";
00821                 }
00822                 if(ucDecType[1]&0x04)
00823                 {
00824                         sReport += "\r\n";
00825                         sReport += "\t   - with support for DESFire Crypto";
00826                 }
00827                 if(ucDecType[1]&0x08)
00828                 {
00829                         sReport += "\r\n";
00830                         sReport += "\t   - with support for MIFARE Plus Crypto";
00831                 }
00832                 if(ucDecType[1]&0x10)
00833                 {
00834                         sReport += "\r\n";
00835                         sReport += "\t   - with support for Kovio";
00836                 }
00837                 if(ucDecType[1]&0x40)
00838                 {
00839                         sReport += "\r\n";
00840                         sReport += "\t   - with support for T=CL with APDU-Length and EXT-MODE";
00841                 }
00842                 if(ucDecType[1]&0x80)
00843                 {
00844                         sReport += "\r\n";
00845                         sReport += "\t   - with support for MAX (Access Control)";
00846                 }
00847                 if(ucDecType[2]&0x01)
00848                 {
00849                         sReport += "\r\n";
00850                         sReport += "\t   - with support for EMVco";
00851                 }
00852                 if(ucDecType[2]&0x02)
00853                 {
00854                         sReport += "\r\n";
00855                         sReport += "\t   - with support for EMV Slot1";
00856                 }
00857                 if(ucDecType[2]&0x04)
00858                 {
00859                         sReport += "\r\n";
00860                         sReport += "\t   - with support for EMV Slot2";
00861                 }
00862                 if(ucDecType[2]&0x08)
00863                 {
00864                         sReport += "\r\n";
00865                         sReport += "\t   - with support for EMV Slot3";
00866                 }
00867                 if(ucDecType[2]&0x10)
00868                 {
00869                         sReport += "\r\n";
00870                         sReport += "\t   - with support for EMV Slot4";
00871                 }
00872                 if(ucDecType[3]&0x01)
00873                 {
00874                         sReport += "\r\n";
00875                         sReport += "\t   - with support for SAM Presence Polling";
00876                 }
00877                 sReport += "\r\n";
00878                 sReport += "\tFirmware-Identifier....";
00879                 for(i=9; i<11; i++)
00880                 {
00881                         sprintf(cBuffer, "0x%02X ", ucDecType[i]);
00882                         sReport += cBuffer;
00883                 }
00884                 sReport += "\r\n";
00885                 break;
00886         }
00887 }
00888 
00889 
00890 void FedmIscReport_ReaderInfo::Add0x05InfoText(string& sReport, bool bSingle)
00891 {
00892         char cBuffer[64];
00893         unsigned char ucSWMajor = 0;
00894         unsigned char ucSWMinor = 0;
00895         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00896 
00897         if(bSingle)
00898         {
00899                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MAJOR, &ucSWMajor);
00900                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO_SW_MINOR, &ucSWMinor);
00901         }
00902         else
00903         {
00904                 ucSWMajor = pInfo->ucBootSwVer[0];
00905                 ucSWMinor = pInfo->ucBootSwVer[1];
00906         }
00907 
00908 //      sReport += "\n\n";
00909 
00910         sReport += "Firmware Version of RFC-Bootloader:";
00911         sReport += "\r\n";
00912         sReport += "\tSoftware Revision:.....";
00913         sprintf(cBuffer, "%02d.%02d", ucSWMajor, ucSWMinor);
00914         sReport += cBuffer;
00915         sReport += "\r\n";
00916 }
00917 
00918 
00919 void FedmIscReport_ReaderInfo::Add0x06InfoText(string& sReport, bool bSingle)
00920 {
00921         char cBuffer[64];
00922         unsigned char ucInfo[32];
00923         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00924 
00925         if(bSingle)
00926         {
00927                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 8);
00928         }
00929         else
00930         {
00931                 ucInfo[0] = pInfo->ucKeybStatus[0];
00932                 ucInfo[1] = pInfo->ucKeybStatus[1];
00933                 ucInfo[2] = pInfo->ucKeybSwVer[0];
00934                 ucInfo[3] = pInfo->ucKeybSwVer[1];
00935                 ucInfo[4] = pInfo->ucKeybHwVer[0];
00936                 ucInfo[5] = pInfo->ucKeybHwVer[1];
00937                 ucInfo[6] = pInfo->ucKeybHwVer[2];
00938                 ucInfo[7] = pInfo->ucKeybHwVer[3];
00939         }
00940 
00941 //      sReport += "\n\n";
00942 
00943         sReport += "Info about Keyboard-Controller:";
00944         sReport += "\r\n";
00945         sReport += "\tStatus:................";
00946         sprintf(cBuffer, "0x%02X 0x%02X", ucInfo[0], ucInfo[1]);
00947         sReport += cBuffer;
00948         sReport += "\r\n";
00949         if(ucInfo[0] & 0x01)
00950         {
00951                 sReport += "\t  - The Reader is equipped with a Keyboard\r\n";
00952                 if(ucInfo[1] & 0x01)
00953                         sReport += "\t  - The Keyboard-Controller signals an error\r\n";
00954                 if(ucInfo[1] & 0x02)
00955                         sReport += "\t  - The Keyboard-Controller is in update mode\r\n";
00956 
00957                 sReport += "\tSoftware Revision:.....";
00958                 sprintf(cBuffer, "%02d.%02d", ucInfo[2], ucInfo[3]);
00959                 sReport += cBuffer;
00960                 sReport += "\r\n";
00961                 sReport += "\tHardware Revision:.....";
00962                 sprintf(cBuffer, "0x%02X%02X%02X%02X", ucInfo[4], ucInfo[5], ucInfo[6], ucInfo[7]);
00963                 sReport += cBuffer;
00964         }
00965         else
00966         {
00967                 sReport += "\t- The Reader is not equipped with a Keyboard";
00968         }
00969         sReport += "\r\n";
00970 }
00971 
00972 
00973 void FedmIscReport_ReaderInfo::Add0x07InfoText(string& sReport, bool bSingle)
00974 {
00975         char cBuffer[64];
00976         unsigned char ucInfo[32];
00977         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
00978 
00979         if(bSingle)
00980         {
00981                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 7);
00982         }
00983         else
00984         {
00985                 ucInfo[0] = pInfo->ucCprioSwVer[0];
00986                 ucInfo[1] = pInfo->ucCprioSwVer[1];
00987                 ucInfo[2] = pInfo->ucCprioHwVer;
00988                 ucInfo[3] = pInfo->ucCprioNoOfInputs;
00989                 ucInfo[4] = pInfo->ucCprioNoOfOutputs;
00990                 ucInfo[5] = pInfo->ucCprioNoOfRelays;
00991                 ucInfo[6] = pInfo->ucCprioNoOfSignalers;
00992         }
00993 
00994 
00995         sReport += "Info about CPRIO unit:";
00996         sReport += "\r\n";
00997 
00998         if(     ucInfo[3] == 0 &&
00999                 ucInfo[4] == 0 &&
01000                 ucInfo[5] == 0 &&
01001                 ucInfo[6] == 0 )
01002         {
01003                 sReport += "\t  - no CPRIO unit detected\r\n";
01004         }
01005         else
01006         {
01007                 sReport += "\tSoftware Revision:.....";
01008                 sprintf(cBuffer, "%02d.%02d", ucInfo[0], ucInfo[1]);
01009                 sReport += cBuffer;
01010                 sReport += "\r\n";
01011                 sReport += "\tHardware Revision:.....";
01012                 sprintf(cBuffer, "0x%02X", ucInfo[2]);
01013                 sReport += cBuffer;
01014                 sReport += "\r\n";
01015                 sprintf(cBuffer, "\t%d Inputs\r\n", ucInfo[3]);
01016                 sReport += cBuffer;
01017                 sprintf(cBuffer, "\t%d Outputs\r\n", ucInfo[4]);
01018                 sReport += cBuffer;
01019                 sprintf(cBuffer, "\t%d Relays\r\n", ucInfo[5]);
01020                 sReport += cBuffer;
01021                 sprintf(cBuffer, "\t%d Signalers\r\n", ucInfo[6]);
01022                 sReport += cBuffer;
01023         }
01024 //      sReport += "\r\n";
01025 }
01026 
01027 
01028 void FedmIscReport_ReaderInfo::Add0x08InfoText(string& sReport, bool bSingle)
01029 {
01030         char cBuffer[64];
01031         unsigned char ucInfo[32];
01032         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01033 
01034         if(bSingle)
01035         {
01036                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 14);
01037         }
01038         else
01039         {
01040                 memcpy(ucInfo, pInfo->ucRfcSupportedTagDriver, 14);
01041         }
01042 
01043 
01044         sReport += "Info about supported Transponder Types:";
01045         sReport += "\r\n";
01046 
01047         for(int i=0; i<14; i++)
01048         {
01049                 if(ucInfo[i] != 0xFF)
01050                 {
01051                         sprintf(cBuffer, "\t0x%02X - %s\r\n", ucInfo[i], m_pReader->GetTagName(ucInfo[i]));
01052                         sReport += cBuffer;
01053                 }
01054         }
01055 }
01056 
01057 
01058 void FedmIscReport_ReaderInfo::Add0x09InfoText(string& sReport, bool bSingle)
01059 {
01060         char cBuffer[64];
01061         unsigned char ucInfo[32];
01062         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01063 
01064         if(bSingle)
01065         {
01066                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 14);
01067         }
01068         else
01069         {
01070                 memcpy(ucInfo, pInfo->ucWlanVer, 14);
01071         }
01072 
01073 
01074         sReport += "Info from WLAN-Module:";
01075         sReport += "\r\n\t";
01076 
01077         for(int cnt=0; cnt<14; cnt++)
01078         {
01079                 if(cnt > 0)
01080                 {
01081                         sReport += " - ";
01082                 }
01083 
01084                 sprintf(cBuffer, "0x%02X", ucInfo[cnt]);
01085                 sReport += cBuffer;
01086         }
01087         sReport += "\r\n";
01088 }
01089 
01090 
01091 void FedmIscReport_ReaderInfo::Add0x10InfoText(string& sReport, bool bSingle)
01092 {
01093         char cBuffer[64];
01094         unsigned char ucDecType[32];
01095         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01096 
01097         if(bSingle)
01098         {
01099                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucDecType, 11);
01100         }
01101         else
01102         {
01103                 ucDecType[0] = pInfo->ucRfcHwInfo[0];
01104                 ucDecType[1] = pInfo->ucRfcHwInfo[1];
01105                 ucDecType[2] = pInfo->ucRfcDHw[0];
01106                 ucDecType[3] = pInfo->ucRfcDHw[1];
01107                 ucDecType[4] = pInfo->ucRfcAHw[0];
01108                 ucDecType[5] = pInfo->ucRfcAHw[1];
01109                 ucDecType[6] = pInfo->ucRfcFrequency;
01110                 ucDecType[7] = pInfo->ucRfcPortTypes;
01111                 ucDecType[8] = pInfo->ucReserved2;
01112                 ucDecType[9] = pInfo->ucRfcInfo;
01113                 ucDecType[10] = pInfo->ucBatteryStatus;
01114         }
01115 
01116 //      sReport += "\n\n";
01117 
01118         sReport += "Hardware Information:";
01119         sReport += "\r\n";
01120         sprintf(cBuffer, "\t0x%02X%02X - 0x%02X%02X - 0x%02X%02X",
01121                                 ucDecType[0],
01122                                 ucDecType[1],
01123                                 ucDecType[2],
01124                                 ucDecType[3],
01125                                 ucDecType[4],
01126                                 ucDecType[5]);
01127 
01128         sReport += cBuffer;
01129 
01130 /*      if( m_pReader->GetReaderType() == FEDM_ISC_TYPE_ISCLRU3000 && 
01131                 m_pReader->m_mapOemNames.find(FEDM_ISC_TYPE_ISCLRU3000) == m_pReader->m_mapOemNames.end())
01132         {
01133                 if( (ucDecType[1] & 0xC0) == 0x00)
01134                 {
01135                         sReport += "\r\n";
01136                         sReport += "\t";
01137                         sReport += FEDM_ISC_NAME_ISCLRU3500;
01138                         sReport +=" identified";
01139                 }
01140         }*/
01141 
01142 //      if(pInfo->bIsRfcFrequency)
01143         {
01144                 switch(m_pReader->GetReaderType())
01145                 {
01146                 case FEDM_ISC_TYPE_ISCLRU2000:
01147                         if(pInfo->ucRfcSwVer[0] >= 2)
01148                         {
01149                                 sReport += "\r\n";
01150                                 sReport += "\tFrequency Information:.";
01151                                 if((ucDecType[6]&0x03) == 1)
01152                                         sReport += "EU";
01153                                 else if((ucDecType[6]&0x03) == 2)
01154                                         sReport += "FCC";
01155                                 else
01156                                         sReport += "unknown";
01157 
01158                                 sReport += "\r\n";
01159                                 sReport += "\tSupported Port Types:..";
01160                                 if(ucDecType[7] & 0x01)
01161                                 {
01162                                         sReport += "Serial";
01163                                         if(ucDecType[7] & 0xFE)
01164                                                 sReport += ", ";
01165                                 }
01166                                 if(ucDecType[7] & 0x02)
01167                                 {
01168                                         sReport += "RS4xx";
01169                                         if(ucDecType[7] & 0xFC)
01170                                         sReport += ", ";
01171                                 }
01172                                 if(ucDecType[7] & 0x04)
01173                                 {
01174                                         sReport += "LAN";
01175                                         if(ucDecType[7] & 0xF8)
01176                                                 sReport += ", ";
01177                                 }
01178                                 if(ucDecType[7] & 0x08)
01179                                 {
01180                                         sReport += "WLAN";
01181                                         if(ucDecType[7] & 0xF0)
01182                                                 sReport += ", ";
01183                                 }
01184                         }
01185                         break;
01186 
01187                 case FEDM_ISC_TYPE_ISCPRHD102:
01188                 case FEDM_ISC_TYPE_ISCMRU102:
01189                 case FEDM_ISC_TYPE_ISCMU02:
01190                 case FEDM_ISC_TYPE_MAXU1002:
01191                 case FEDM_ISC_TYPE_ISCLRU1002:
01192                 case FEDM_ISC_TYPE_ISCLRU3000:
01193                         sReport += "\r\n";
01194                         sReport += "\tFrequency Information:.";
01195                         if((ucDecType[6]&0x03) == 1)
01196                                 sReport += "EU";
01197                         else if((ucDecType[6]&0x03) == 2)
01198                                 sReport += "FCC";
01199                         else if((ucDecType[6]&0x03) == 3)
01200                                 sReport += "EU and FCC";
01201                         else
01202                                 sReport += "unknown";
01203 
01204                         sReport += "\r\n";
01205                         sReport += "\tSupported Port Types:..";
01206                         if(ucDecType[7] & 0x01)
01207                         {
01208                                 sReport += "Serial";
01209                                 if(ucDecType[7] & 0xFE)
01210                                         sReport += ", ";
01211                         }
01212                         if(ucDecType[7] & 0x02)
01213                         {
01214                                 sReport += "RS4xx";
01215                                 if(ucDecType[7] & 0xFC)
01216                                 sReport += ", ";
01217                         }
01218                         if(ucDecType[7] & 0x04)
01219                         {
01220                                 sReport += "LAN";
01221                                 if(ucDecType[7] & 0xF8)
01222                                         sReport += ", ";
01223                         }
01224                         if(ucDecType[7] & 0x08)
01225                         {
01226                                 sReport += "WLAN";
01227                                 if(ucDecType[7] & 0xF0)
01228                                         sReport += ", ";
01229                         }
01230                         if(ucDecType[7] & 0x10)
01231                         {
01232                                 sReport += "USB";
01233                                 if(ucDecType[7] & 0xE0)
01234                                         sReport += ", ";
01235                         }
01236                         if(ucDecType[7] & 0x20)
01237                         {
01238                                 sReport += "Bluetooth";
01239                                 if(ucDecType[7] & 0xC0)
01240                                         sReport += ", ";
01241                         }
01242                         if(ucDecType[7] & 0x80)
01243                         {
01244                                 sReport += "Discovery";
01245                         }
01246 
01247                         break;
01248 
01249                 case FEDM_ISC_TYPE_ISCMRU200:
01250                         sReport += "\r\n";
01251                         sReport += "\tFrequency Information:.";
01252                         if((ucDecType[6]&0x03) == 1)
01253                                 sReport += "EU";
01254                         else if((ucDecType[6]&0x03) == 2)
01255                                 sReport += "FCC";
01256                         else
01257                                 sReport += "unknown";
01258 
01259                         break;
01260 
01261                 // megalock C
01262                 case FEDM_ISC_TYPE_MLC_COM:
01263                         sReport += "\r\n";
01264                         sReport += "\tSupported Port Types:..";
01265                         if(ucDecType[7] & 0x10)
01266                         {
01267                                 sReport += "USB";
01268                                 if(ucDecType[7] & 0xE0)
01269                                         sReport += ", ";
01270                         }
01271 
01272                         sReport += "\r\n";
01273                         sReport += "\tBattery Status:........";
01274                         sprintf(cBuffer, "%d", (int)ucDecType[10]);
01275                         sReport += cBuffer;
01276                         
01277                         break;
01278 
01279 
01280                 default:
01281                         sReport += "\r\n";
01282                         sReport += "\tSupported Port Types:..";
01283                         if(ucDecType[7] & 0x01)
01284                         {
01285                                 sReport += "Serial";
01286                                 if(ucDecType[7] & 0xFE)
01287                                         sReport += ", ";
01288                         }
01289                         if(ucDecType[7] & 0x02)
01290                         {
01291                                 sReport += "RS4xx";
01292                                 if(ucDecType[7] & 0xFC)
01293                                 sReport += ", ";
01294                         }
01295                         if(ucDecType[7] & 0x04)
01296                         {
01297                                 sReport += "LAN";
01298                                 if(ucDecType[7] & 0xF8)
01299                                         sReport += ", ";
01300                         }
01301                         if(ucDecType[7] & 0x08)
01302                         {
01303                                 sReport += "WLAN";
01304                                 if(ucDecType[7] & 0xF0)
01305                                         sReport += ", ";
01306                         }
01307                         if(ucDecType[7] & 0x10)
01308                         {
01309                                 sReport += "USB";
01310                                 if(ucDecType[7] & 0xE0)
01311                                         sReport += ", ";
01312                         }
01313                         if(ucDecType[7] & 0x20)
01314                         {
01315                                 sReport += "Bluetooth";
01316                                 if(ucDecType[7] & 0xC0)
01317                                         sReport += ", ";
01318                         }
01319                         if(ucDecType[7] & 0x80)
01320                         {
01321                                 sReport += "Discovery";
01322                         }
01323 
01324                         break;
01325                 }
01326         }
01327 
01328         sReport += "\r\n";
01329 }
01330 
01331 
01332 void FedmIscReport_ReaderInfo::Add0x11InfoText(string& sReport, bool bSingle)
01333 {
01334         char cBuffer[64];
01335         unsigned char ucSlotInfo[32];
01336         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01337 
01338         if(bSingle)
01339         {
01340                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucSlotInfo, 5);
01341         }
01342         else
01343         {
01344                 ucSlotInfo[0] = pInfo->ucNoOfSlots;
01345                 ucSlotInfo[1] = pInfo->ucSlotInfo[0];
01346                 ucSlotInfo[2] = pInfo->ucSlotInfo[1];
01347                 ucSlotInfo[3] = pInfo->ucSlotInfo[2];
01348                 ucSlotInfo[4] = pInfo->ucSlotInfo[3];
01349         }
01350 
01351 //      sReport += "\n\n";
01352 
01353         sReport += "SAM Information:";
01354         sReport += "\r\n";
01355         sReport += "\tNumber of SAM Slots:...";
01356         sprintf(cBuffer, "%u", (unsigned int)ucSlotInfo[0]);
01357         sReport += cBuffer;
01358         sReport += "\r\n";
01359 
01360         if(ucSlotInfo[0] >= 1)
01361         {
01362                 if(ucSlotInfo[1] & 0x01)
01363                 {
01364                         sReport += "\t   - SAM inserted in socket 1\r\n";
01365                         sReport += "\t   Slot-Type: ";
01366                         switch( ((ucSlotInfo[1] & 0xF0) >> 4) )
01367                         {
01368                         case 0x00:
01369                                 sReport += "smartcard holder slot\r\n";
01370                                 break;
01371                         case 0x01:
01372                                 sReport += "NXP SAM\r\n";
01373                                 break;
01374                         case 0x02:
01375                                 sReport += "Infineon SAM\r\n";
01376                                 break;
01377                         }
01378                 }
01379                 else
01380                 {
01381                         sReport += "\t   - SAM socket 1 is not used\r\n";
01382                 }
01383         }
01384 
01385         if(ucSlotInfo[0] >= 2)
01386         {
01387                 if(ucSlotInfo[2] & 0x01)
01388                 {
01389                         sReport += "\t   - SAM inserted in socket 2\r\n";
01390                         sReport += "\t   Slot-Type: ";
01391                         switch( ((ucSlotInfo[2] & 0xF0) >> 4) )
01392                         {
01393                         case 0x00:
01394                                 sReport += "smartcard holder slot\r\n";
01395                                 break;
01396                         case 0x01:
01397                                 sReport += "NXP SAM\r\n";
01398                                 break;
01399                         case 0x02:
01400                                 sReport += "Infineon SAM\r\n";
01401                                 break;
01402                         }
01403                 }
01404                 else
01405                 {
01406                         sReport += "\t   - SAM socket 2 is not used\r\n";
01407                 }
01408         }
01409 
01410         if(ucSlotInfo[0] >= 3)
01411         {
01412                 if(ucSlotInfo[3] & 0x01)
01413                 {
01414                         sReport += "\t   - SAM inserted in socket 3\r\n";
01415                         sReport += "\t   Slot-Type: ";
01416                         switch( ((ucSlotInfo[3] & 0xF0) >> 4) )
01417                         {
01418                         case 0x00:
01419                                 sReport += "smartcard holder slot\r\n";
01420                                 break;
01421                         case 0x01:
01422                                 sReport += "NXP SAM\r\n";
01423                                 break;
01424                         case 0x02:
01425                                 sReport += "Infineon SAM\r\n";
01426                                 break;
01427                         }
01428                 }
01429                 else
01430                 {
01431                         sReport += "\t   - SAM socket 3 is not used\r\n";
01432                 }
01433         }
01434 
01435         if(ucSlotInfo[0] >= 4)
01436         {
01437                 if(ucSlotInfo[4] & 0x01)
01438                 {
01439                         sReport += "\t   - SAM inserted in socket 4\r\n";
01440                         sReport += "\t   Slot-Type: ";
01441                         switch( ((ucSlotInfo[4] & 0xF0) >> 4) )
01442                         {
01443                         case 0x00:
01444                                 sReport += "smartcard holder slot\r\n";
01445                                 break;
01446                         case 0x01:
01447                                 sReport += "NXP SAM\r\n";
01448                                 break;
01449                         case 0x02:
01450                                 sReport += "Infineon SAM\r\n";
01451                                 break;
01452                         }
01453                 }
01454                 else
01455                 {
01456                         sReport += "\t   - SAM socket 4 is not used\r\n";
01457                 }
01458         }
01459 }
01460 
01461 
01462 void FedmIscReport_ReaderInfo::Add0x12InfoText(string& sReport, bool bSingle)
01463 {
01464         char cBuffer[64];
01465         unsigned char ucInfo[32];
01466         unsigned int uiFlashSize = 0;
01467         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01468 
01469         if(bSingle)
01470         {
01471                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 8);
01472         }
01473         else
01474         {
01475                 memcpy(&ucInfo[0], &pInfo->ucRfcCpuManufacturer, 8);
01476         }
01477 
01478         uiFlashSize  = (((unsigned int)ucInfo[4])<<24);
01479         uiFlashSize |= (((unsigned int)ucInfo[5])<<16);
01480         uiFlashSize |= (((unsigned int)ucInfo[6])<< 8);
01481         uiFlashSize |=   (unsigned int)ucInfo[7];
01482 
01483         sReport += "CPU Information of RF Communication Controller:";
01484         sReport += "\r\n";
01485         sprintf(cBuffer, "\tManufacturer:...%d\r\n", ucInfo[0]);
01486         sReport += cBuffer;
01487         sprintf(cBuffer, "\tType:...........0x%02X%02X\r\n", ucInfo[1], ucInfo[2]);
01488         sReport += cBuffer;
01489         sprintf(cBuffer, "\tRevision:.......%d\r\n", ucInfo[3]);
01490         sReport += cBuffer;
01491         sprintf(cBuffer, "\tFlash-Size:.....%u KB\r\n", uiFlashSize);
01492         sReport += cBuffer;
01493 }
01494 
01495 
01496 void FedmIscReport_ReaderInfo::Add0x40InfoText(string& sReport, bool bSingle)
01497 {
01498         char cBuffer[64];
01499         unsigned char ucInfo[32];
01500         unsigned int uiNoOfCfgPages = 0;
01501         string sFormat = "";
01502         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01503 
01504         if(bSingle)
01505         {
01506                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 18);
01507         }
01508         else
01509         {
01510                 ucInfo[0] = pInfo->ucNoOfCfgPages[0];
01511                 ucInfo[1] = pInfo->ucNoOfCfgPages[1];
01512 
01513                 for(int i=0; i<16; i++)
01514                 {
01515                         ucInfo[2+i] = pInfo->ucCfgReadPermissions[i];
01516                 }
01517         }
01518 
01519         uiNoOfCfgPages = (ucInfo[0]<<8) + ucInfo[1];
01520 
01521         for(unsigned int i=0; i<uiNoOfCfgPages/8; i++)
01522                 sFormat += "%02X";
01523 
01524         if(uiNoOfCfgPages%8)
01525                 sFormat += "%02X";
01526 
01527 
01528 //      sReport += "\n\n";
01529         sReport += "Configuration Information for read";
01530         sReport += "\r\n";
01531 
01532         sReport += "\tCFG Pages:.............";
01533         sprintf(cBuffer, "%u", uiNoOfCfgPages);
01534         sReport += cBuffer;
01535         sReport += "\r\n";
01536 
01537         sReport += "\tCFG read permission:...";
01538         sprintf(cBuffer,
01539                         sFormat.c_str(),
01540                         ucInfo[2],
01541                         ucInfo[3],
01542                         ucInfo[4],
01543                         ucInfo[5],
01544                         ucInfo[6],
01545                         ucInfo[7],
01546                         ucInfo[8],
01547                         ucInfo[9],
01548                         ucInfo[10],
01549                         ucInfo[11],
01550                         ucInfo[12],
01551                         ucInfo[13],
01552                         ucInfo[14],
01553                         ucInfo[15],
01554                         ucInfo[16],
01555                         ucInfo[17] );
01556 
01557         sReport += cBuffer;
01558         sReport += "\r\n";
01559 }
01560 
01561 
01562 void FedmIscReport_ReaderInfo::Add0x41InfoText(string& sReport, bool bSingle)
01563 {
01564         char cBuffer[64];
01565         unsigned char ucInfo[32];
01566         unsigned int uiNoOfCfgPages = 0;
01567         string sFormat = "";
01568         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01569 
01570         if(bSingle)
01571         {
01572                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 18);
01573         }
01574         else
01575         {
01576                 ucInfo[0] = pInfo->ucNoOfCfgPages[0];
01577                 ucInfo[1] = pInfo->ucNoOfCfgPages[1];
01578 
01579                 for(int i=0; i<16; i++)
01580                 {
01581                         ucInfo[2+i] = pInfo->ucCfgReadPermissions[i];
01582                 }
01583         }
01584 
01585         uiNoOfCfgPages = (ucInfo[0]<<8) + ucInfo[1];
01586 
01587         for(unsigned int i=0; i<uiNoOfCfgPages/8; i++)
01588                 sFormat += "%02X";
01589 
01590         if(uiNoOfCfgPages%8)
01591                 sFormat += "%02X";
01592 
01593 
01594 //      sReport += "\n\n";
01595         sReport += "Configuration Information for write";
01596         sReport += "\r\n";
01597 
01598         sReport += "\tCFG Pages:.............";
01599         sprintf(cBuffer, "%u", uiNoOfCfgPages);
01600         sReport += cBuffer;
01601         sReport += "\r\n";
01602 
01603         sReport += "\tCFG write permission:..";
01604         sprintf(cBuffer,
01605                         sFormat.c_str(),
01606                         ucInfo[2],
01607                         ucInfo[3],
01608                         ucInfo[4],
01609                         ucInfo[5],
01610                         ucInfo[6],
01611                         ucInfo[7],
01612                         ucInfo[8],
01613                         ucInfo[9],
01614                         ucInfo[10],
01615                         ucInfo[11],
01616                         ucInfo[12],
01617                         ucInfo[13],
01618                         ucInfo[14],
01619                         ucInfo[15],
01620                         ucInfo[16],
01621                         ucInfo[17] );
01622 
01623         sReport += cBuffer;
01624         sReport += "\r\n";
01625 }
01626 
01627 
01628 void FedmIscReport_ReaderInfo::Add0x50InfoText(string& sReport, bool bSingle)
01629 {
01630         char cBuffer[64];
01631         unsigned char ucInfo[32];
01632         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01633 
01634         if(bSingle)
01635         {
01636                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
01637                 sReport += "LAN-Information\n";
01638         }
01639         else
01640         {
01641                 ucInfo[0] = pInfo->ucLanFlags;
01642                 memcpy(&ucInfo[1], &pInfo->ucLanMac[0], 6);
01643                 ucInfo[7] = pInfo->ucLanLinkInfo;
01644         }
01645 
01646 //      sReport += "\r\n";
01647         if( (ucInfo[0] & 0x02) ||       // IPv4 supported
01648                 (ucInfo[0] & 0x01) )    // IPv6 supported
01649         {
01650                 if( ucInfo[0] & ((ucInfo[0]&0x03)<<2) )
01651                 {
01652                         sReport += "\tLAN disabled";
01653                 }
01654                 else
01655                 {
01656                         sReport += "\tMAC-Address:...........";
01657                         sprintf(cBuffer,
01658                                         "%02X:%02X:%02X:%02X:%02X:%02X",
01659                                         ucInfo[1],
01660                                         ucInfo[2],
01661                                         ucInfo[3],
01662                                         ucInfo[4],
01663                                         ucInfo[5],
01664                                         ucInfo[6] );
01665 
01666                         sReport += cBuffer;
01667                 }
01668         }
01669 
01670         sReport += "\r\n";
01671 
01672         if (ucInfo[7] & 0x01)
01673         {
01674                 sReport += "\tAuto-Negotiation:......Off";
01675                 sReport += "\r\n";
01676 
01677                 if (ucInfo[7] & 0x02)
01678                 {
01679                         sReport += "\tDuplexmode:............Full Duplex";
01680                         sReport += "\r\n";
01681                 }
01682                 else
01683                 {
01684                         sReport += "\tDuplexmode:............Half Duplex";
01685                         sReport += "\r\n";
01686                 }
01687 
01688                 if (ucInfo[7] & 0x04)
01689                 {
01690                         sReport += "\tSpeed:.................100 Mbit";
01691                         sReport += "\r\n";
01692                 }
01693                 else
01694                 {
01695                         sReport += "\tSpeed:.................10 Mbit";
01696                         sReport += "\r\n";
01697                 }
01698         }
01699 }
01700 
01701 
01702 void FedmIscReport_ReaderInfo::Add0x51InfoText(string& sReport, bool bSingle)
01703 {
01704         char cBuffer[256];
01705         unsigned char ucInfo[32];
01706         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01707 
01708         if(bSingle)
01709         {
01710                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
01711                 sReport += "LAN-Information\n";
01712         }
01713         else
01714         {
01715                 ucInfo[0] = pInfo->ucLanFlags;
01716                 memcpy(&ucInfo[1], &pInfo->ucLanIpV4[0], 4);
01717                 memcpy(&ucInfo[5], &pInfo->ucLanIpV6[0], 16);
01718         }
01719 
01720 
01721 //      sReport += "\r\n";
01722         if(ucInfo[0] & 0x02)    // IPv4 supported
01723         {
01724                 if(ucInfo[0] & 0x08)    // IPv4 disabled
01725                 {
01726                         sReport += "\tIPv4-Channel disabled";
01727                 }
01728                 else
01729                 {
01730                         if(ucInfo[0] & 0x20)    // DHCP v4
01731                                 sReport += "\tIPv4-Address:..[DHCP]..";
01732                         else
01733                                 sReport += "\tIPv4-Address:..........";
01734 
01735                         sprintf(cBuffer,
01736                                         "%d.%d.%d.%d",
01737                                         ucInfo[1],
01738                                         ucInfo[2],
01739                                         ucInfo[3],
01740                                         ucInfo[4] );
01741 
01742                         sReport += cBuffer;
01743                 }
01744         }
01745         
01746         if(ucInfo[0] & 0x01)    // IPv6 supported
01747         {
01748                 if(ucInfo[0] & 0x04)    // IPv6 disabled
01749                 {
01750                         sReport += "\tIPv6-Channel disabled";
01751                 }
01752                 else
01753                 {
01754                         if(ucInfo[0] & 0x10)    // DHCP v6
01755                                 sReport += "\tIPv6-Address:..[DHCP]..";
01756                         else
01757                                 sReport += "\tIPv6-Address:..........";
01758 
01759                         sprintf(cBuffer,
01760                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
01761                                         ucInfo[5],
01762                                         ucInfo[6],
01763                                         ucInfo[7],
01764                                         ucInfo[8],
01765                                         ucInfo[9],
01766                                         ucInfo[10],
01767                                         ucInfo[11],
01768                                         ucInfo[12],
01769                                         ucInfo[13],
01770                                         ucInfo[14],
01771                                         ucInfo[15],
01772                                         ucInfo[16],
01773                                         ucInfo[17],
01774                                         ucInfo[18],
01775                                         ucInfo[19],
01776                                         ucInfo[20] );
01777 
01778                         sReport += cBuffer;
01779                 }
01780         }
01781 
01782         sReport += "\r\n";
01783 }
01784 
01785 
01786 void FedmIscReport_ReaderInfo::Add0x52InfoText(string& sReport, bool bSingle)
01787 {
01788         char cBuffer[256];
01789         unsigned char ucInfo[32];
01790         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01791 
01792         if(bSingle)
01793         {
01794                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
01795                 sReport += "LAN-Information\n";
01796         }
01797         else
01798         {
01799                 ucInfo[0] = pInfo->ucLanFlags;
01800                 memcpy(&ucInfo[1], &pInfo->ucLanNetmaskV4[0], 4);
01801                 memcpy(&ucInfo[5], &pInfo->ucLanNetmaskV6[0], 16);
01802         }
01803 
01804 
01805 //      sReport += "\r\n";
01806         if(ucInfo[0] & 0x02)    // IPv4 supported
01807         {
01808                 if(ucInfo[0] & 0x08)    // IPv4 disabled
01809                 {
01810                         sReport += "\tIPv4-Channel disabled";
01811                 }
01812                 else
01813                 {
01814                         if(ucInfo[0] & 0x20)    // DHCP v4
01815                                 sReport += "\tIPv4-Netmask:..[DHCP]..";
01816                         else
01817                                 sReport += "\tIPv4-Netmask:..........";
01818 
01819                         sprintf(cBuffer,
01820                                         "%d.%d.%d.%d",
01821                                         ucInfo[1],
01822                                         ucInfo[2],
01823                                         ucInfo[3],
01824                                         ucInfo[4] );
01825         
01826                         sReport += cBuffer;
01827                 }
01828         }
01829 
01830         if(ucInfo[0] & 0x01)    // IPv6 supported
01831         {
01832                 if(ucInfo[0] & 0x04)    // IPv6 disabled
01833                 {
01834                         sReport += "\tIPv6-Channel disabled";
01835                 }
01836                 else
01837                 {
01838                         if(ucInfo[0] & 0x10)    // DHCP v6
01839                                 sReport += "\tIPv6-Netmask:..[DHCP]..";
01840                         else
01841                                 sReport += "\tIPv6-Netmask:..........";
01842 
01843                         sprintf(cBuffer,
01844                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
01845                                         ucInfo[5],
01846                                         ucInfo[6],
01847                                         ucInfo[7],
01848                                         ucInfo[8],
01849                                         ucInfo[9],
01850                                         ucInfo[10],
01851                                         ucInfo[11],
01852                                         ucInfo[12],
01853                                         ucInfo[13],
01854                                         ucInfo[14],
01855                                         ucInfo[15],
01856                                         ucInfo[16],
01857                                         ucInfo[17],
01858                                         ucInfo[18],
01859                                         ucInfo[19],
01860                                         ucInfo[20] );
01861 
01862                         sReport += cBuffer;
01863                 }
01864         }
01865 
01866         sReport += "\r\n";
01867 }
01868 
01869 
01870 void FedmIscReport_ReaderInfo::Add0x53InfoText(string& sReport, bool bSingle)
01871 {
01872         char cBuffer[256];
01873         unsigned char ucInfo[32];
01874         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01875 
01876         if(bSingle)
01877         {
01878                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
01879                 sReport += "LAN-Information\n";
01880         }
01881         else
01882         {
01883                 ucInfo[0] = pInfo->ucLanFlags;
01884                 memcpy(&ucInfo[1], &pInfo->ucLanGatewayV4[0], 4);
01885                 memcpy(&ucInfo[5], &pInfo->ucLanGatewayV6[0], 16);
01886         }
01887 
01888 
01889 //      sReport += "\r\n";
01890         if(ucInfo[0] & 0x02)    // IPv4 supported
01891         {
01892                 if(ucInfo[0] & 0x08)    // IPv4 disabled
01893                 {
01894                         sReport += "\tIPv4-Channel disabled";
01895                 }
01896                 else
01897                 {
01898                         if(ucInfo[0] & 0x20)    // DHCP v4
01899                                 sReport += "\tIPv4-Gateway:..[DHCP]..";
01900                         else
01901                                 sReport += "\tIPv4-Gateway:..........";
01902 
01903                         sprintf(cBuffer,
01904                                         "%d.%d.%d.%d",
01905                                         ucInfo[1],
01906                                         ucInfo[2],
01907                                         ucInfo[3],
01908                                         ucInfo[4] );
01909 
01910                         sReport += cBuffer;
01911                 }
01912         }
01913 
01914         if(ucInfo[0] & 0x01)    // IPv6 supported
01915         {
01916                 if(ucInfo[0] & 0x04)    // IPv6 disabled
01917                 {
01918                         sReport += "\tIPv6-Channel disabled";
01919                 }
01920                 else
01921                 {
01922                         if(ucInfo[0] & 0x10)    // DHCP v6
01923                                 sReport += "\tIPv6-Gateway:..[DHCP]..";
01924                         else
01925                                 sReport += "\tIPv6-Gateway:..........";
01926 
01927                         sprintf(cBuffer,
01928                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
01929                                         ucInfo[5],
01930                                         ucInfo[6],
01931                                         ucInfo[7],
01932                                         ucInfo[8],
01933                                         ucInfo[9],
01934                                         ucInfo[10],
01935                                         ucInfo[11],
01936                                         ucInfo[12],
01937                                         ucInfo[13],
01938                                         ucInfo[14],
01939                                         ucInfo[15],
01940                                         ucInfo[16],
01941                                         ucInfo[17],
01942                                         ucInfo[18],
01943                                         ucInfo[19],
01944                                         ucInfo[20] );
01945 
01946                         sReport += cBuffer;
01947                 }
01948         }
01949 
01950         sReport += "\r\n";
01951 }
01952 
01953 
01954 void FedmIscReport_ReaderInfo::Add0x54InfoText(string& sReport, bool bSingle)
01955 {
01956         char cBuffer[64];
01957         unsigned char ucInfo[32];
01958         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
01959 
01960         if(bSingle)
01961         {
01962                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
01963                 sReport += "WLAN-Information\n";
01964         }
01965         else
01966         {
01967                 ucInfo[0] = pInfo->ucWlanFlags;
01968                 memcpy(&ucInfo[1], &pInfo->ucWlanMac[0], 6);
01969         }
01970 
01971         if( (ucInfo[0] & 0x02) ||       // IPv4 supported
01972                 (ucInfo[0] & 0x01) )    // IPv6 supported
01973         {
01974                 if( ucInfo[0] & ((ucInfo[0]&0x03)<<2) )
01975                 {
01976                         sReport += "\tWLAN disabled";
01977                 }
01978                 else
01979                 {
01980                         sReport += "\tMAC-Address:...........";
01981                         sprintf(cBuffer,
01982                                         "%02X:%02X:%02X:%02X:%02X:%02X",
01983                                         ucInfo[1],
01984                                         ucInfo[2],
01985                                         ucInfo[3],
01986                                         ucInfo[4],
01987                                         ucInfo[5],
01988                                         ucInfo[6] );
01989 
01990                         sReport += cBuffer;
01991                 }
01992         }
01993 
01994         sReport += "\r\n";
01995 }
01996 
01997 
01998 void FedmIscReport_ReaderInfo::Add0x55InfoText(string& sReport, bool bSingle)
01999 {
02000         char cBuffer[256];
02001         unsigned char ucInfo[32];
02002         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02003 
02004         if(bSingle)
02005         {
02006                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
02007                 sReport += "WLAN-Information\n";
02008         }
02009         else
02010         {
02011                 ucInfo[0] = pInfo->ucWlanFlags;
02012                 memcpy(&ucInfo[1], &pInfo->ucWlanIpV4[0], 4);
02013                 memcpy(&ucInfo[5], &pInfo->ucWlanIpV6[0], 16);
02014         }
02015 
02016 
02017 //      sReport += "\r\n";
02018         if(ucInfo[0] & 0x02)    // IPv4 supported
02019         {
02020                 if(ucInfo[0] & 0x08)    // IPv4 disabled
02021                 {
02022                         sReport += "\tIPv4-Channel disabled";
02023                 }
02024                 else
02025                 {
02026                         if(ucInfo[0] & 0x20)    // DHCP v4
02027                                 sReport += "\tIPv4-Address:..[DHCP]..";
02028                         else
02029                                 sReport += "\tIPv4-Address:..........";
02030                 
02031                                 sprintf(cBuffer,
02032                                         "%d.%d.%d.%d",
02033                                         ucInfo[1],
02034                                         ucInfo[2],
02035                                         ucInfo[3],
02036                                         ucInfo[4] );
02037 
02038                         sReport += cBuffer;
02039                 }
02040         }
02041 
02042         if(ucInfo[0] & 0x01)    // IPv6 supported
02043         {
02044                 if(ucInfo[0] & 0x04)    // IPv6 disabled
02045                 {
02046                         sReport += "\tIPv6-Channel disabled";
02047                 }
02048                 else
02049                 {
02050                         if(ucInfo[0] & 0x10)    // DHCP v6
02051                                 sReport += "\tIPv6-Address:..[DHCP]..";
02052                         else
02053                                 sReport += "\tIPv6-Address:..........";
02054 
02055                         sprintf(cBuffer,
02056                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
02057                                         ucInfo[5],
02058                                         ucInfo[6],
02059                                         ucInfo[7],
02060                                         ucInfo[8],
02061                                         ucInfo[9],
02062                                         ucInfo[10],
02063                                         ucInfo[11],
02064                                         ucInfo[12],
02065                                         ucInfo[13],
02066                                         ucInfo[14],
02067                                         ucInfo[15],
02068                                         ucInfo[16],
02069                                         ucInfo[17],
02070                                         ucInfo[18],
02071                                         ucInfo[19],
02072                                         ucInfo[20] );
02073 
02074                         sReport += cBuffer;
02075                 }
02076         }
02077 
02078         sReport += "\r\n";
02079 }
02080 
02081 
02082 void FedmIscReport_ReaderInfo::Add0x56InfoText(string& sReport, bool bSingle)
02083 {
02084         char cBuffer[256];
02085         unsigned char ucInfo[32];
02086         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02087 
02088         if(bSingle)
02089         {
02090                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
02091                 sReport += "WLAN-Information\n";
02092         }
02093         else
02094         {
02095                 ucInfo[0] = pInfo->ucWlanFlags;
02096                 memcpy(&ucInfo[1], &pInfo->ucWlanNetmaskV4[0], 4);
02097                 memcpy(&ucInfo[5], &pInfo->ucWlanNetmaskV6[0], 16);
02098         }
02099 
02100 //      sReport += "\r\n";
02101         if(ucInfo[0] & 0x02)    // IPv4 supported
02102         {
02103                 if(ucInfo[0] & 0x08)    // IPv4 disabled
02104                 {
02105                         sReport += "\tIPv4-Channel disabled";
02106                 }
02107                 else
02108                 {
02109                         if(ucInfo[0] & 0x20)    // DHCP v4
02110                                 sReport += "\tIPv4-Netmask:..[DHCP]..";
02111                         else
02112                                 sReport += "\tIPv4-Netmask:..........";
02113 
02114                         sprintf(cBuffer,
02115                                         "%d.%d.%d.%d",
02116                                         ucInfo[1],
02117                                         ucInfo[2],
02118                                         ucInfo[3],
02119                                         ucInfo[4] );
02120 
02121                         sReport += cBuffer;
02122                 }
02123         }
02124 
02125         if(ucInfo[0] & 0x01)    // IPv6 supported
02126         {
02127                 if(ucInfo[0] & 0x04)    // IPv6 disabled
02128                 {
02129                         sReport += "\tIPv6-Channel disabled";
02130                 }
02131                 else
02132                 {
02133                         if(ucInfo[0] & 0x10)    // DHCP v6
02134                                 sReport += "\tIPv6-Netmask:..[DHCP]..";
02135                         else
02136                                 sReport += "\tIPv6-Netmask:..........";
02137                 
02138                         sprintf(cBuffer,
02139                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
02140                                         ucInfo[5],
02141                                         ucInfo[6],
02142                                         ucInfo[7],
02143                                         ucInfo[8],
02144                                         ucInfo[9],
02145                                         ucInfo[10],
02146                                         ucInfo[11],
02147                                         ucInfo[12],
02148                                         ucInfo[13],
02149                                         ucInfo[14],
02150                                         ucInfo[15],
02151                                         ucInfo[16],
02152                                         ucInfo[17],
02153                                         ucInfo[18],
02154                                         ucInfo[19],
02155                                         ucInfo[20] );
02156 
02157                         sReport += cBuffer;
02158                 }
02159         }
02160 
02161         sReport += "\r\n";
02162 }
02163 
02164 
02165 void FedmIscReport_ReaderInfo::Add0x57InfoText(string& sReport, bool bSingle)
02166 {
02167         char cBuffer[256];
02168         unsigned char ucInfo[32];
02169         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02170 
02171         if(bSingle)
02172         {
02173                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 30);
02174                 sReport += "WLAN-Information\n";
02175         }
02176         else
02177         {
02178                 ucInfo[0] = pInfo->ucWlanFlags;
02179                 memcpy(&ucInfo[1], &pInfo->ucWlanGatewayV4[0], 4);
02180                 memcpy(&ucInfo[5], &pInfo->ucWlanGatewayV6[0], 16);
02181         }
02182 
02183 //      sReport += "\r\n";
02184         if(ucInfo[0] & 0x02)    // IPv4 supported
02185         {
02186                 if(ucInfo[0] & 0x08)    // IPv4 disabled
02187                 {
02188                         sReport += "\tIPv4-Channel disabled";
02189                 }
02190                 else
02191                 {
02192                         if(ucInfo[0] & 0x20)    // DHCP v4
02193                                 sReport += "\tIPv4-Gateway:..[DHCP]..";
02194                         else
02195                                 sReport += "\tIPv4-Gateway:..........";
02196 
02197                         sprintf(cBuffer,
02198                                         "%d.%d.%d.%d",
02199                                         ucInfo[1],
02200                                         ucInfo[2],
02201                                         ucInfo[3],
02202                                         ucInfo[4] );
02203 
02204                         sReport += cBuffer;
02205                 }
02206         }
02207 
02208         if(ucInfo[0] & 0x01)    // IPv6 supported
02209         {
02210                 if(ucInfo[0] & 0x04)    // IPv6 disabled
02211                 {
02212                         sReport += "\tIPv6-Channel disabled";
02213                 }
02214                 else
02215                 {
02216                         if(ucInfo[0] & 0x10)    // DHCP v6
02217                                 sReport += "\tIPv6-Gateway:..[DHCP]..";
02218                         else
02219                                 sReport += "\tIPv6-Gateway:..........";
02220                 
02221                         sprintf(cBuffer,
02222                                         "%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X:%02X%02X",
02223                                         ucInfo[5],
02224                                         ucInfo[6],
02225                                         ucInfo[7],
02226                                         ucInfo[8],
02227                                         ucInfo[9],
02228                                         ucInfo[10],
02229                                         ucInfo[11],
02230                                         ucInfo[12],
02231                                         ucInfo[13],
02232                                         ucInfo[14],
02233                                         ucInfo[15],
02234                                         ucInfo[16],
02235                                         ucInfo[17],
02236                                         ucInfo[18],
02237                                         ucInfo[19],
02238                                         ucInfo[20] );
02239 
02240                         sReport += cBuffer;
02241                 }
02242         }
02243 
02244         sReport += "\r\n";
02245 }
02246 
02247 void FedmIscReport_ReaderInfo::Add0x60InfoText(string& sReport, bool bSingle)
02248 {
02249         char cBuffer[64];
02250         unsigned char ucInfo[32];
02251         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02252 
02253         if(bSingle)
02254         {
02255                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 18);
02256         }
02257         else
02258         {
02259                 ucInfo[0] = pInfo->ucNoOfInputs;
02260                 ucInfo[1] = pInfo->ucNoOfOutputs;
02261                 ucInfo[2] = pInfo->ucNoOfRelays;
02262         }
02263 
02264         sReport += "Input/Output capabilities";
02265         sReport += "\r\n";
02266 
02267         sReport += "\tNumber of Inputs:......";
02268         sprintf(cBuffer, "%d", ucInfo[0]);
02269         sReport += cBuffer;
02270         sReport += "\r\n";
02271 
02272         sReport += "\tNumber of Outputs:.....";
02273         sprintf(cBuffer, "%d", ucInfo[1]);
02274         sReport += cBuffer;
02275         sReport += "\r\n";
02276 
02277         sReport += "\tNumber of Relays:......";
02278         sprintf(cBuffer, "%d", ucInfo[2]);
02279         sReport += cBuffer;
02280         sReport += "\r\n";
02281 }
02282 
02283 void FedmIscReport_ReaderInfo::Add0x61InfoText(string& sReport, bool bSingle)
02284 {
02285 #if !defined(_FEDM_NO_PD_SUPPORT)
02286         char cBuffer[64];
02287         unsigned char ucInfo[32];
02288         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02289         memset(ucInfo, 0, 32);
02290 
02291         if(bSingle)
02292         {
02293                 m_pReader->GetData(FEDM_ISC_TMP_READER_INFO, ucInfo, 7);
02294         }
02295         else
02296         {
02297                 ucInfo[0] = pInfo->ucNoOfPeripheralDevices;
02298                 if(pInfo->ucNoOfPeripheralDevices >= 1)
02299                 {
02300                         ucInfo[1] = pInfo->aPeripheralDevice[0].ucPDType;
02301                         ucInfo[2] = pInfo->aPeripheralDevice[0].ucPDBusAdr;
02302                 }
02303                 if(pInfo->ucNoOfPeripheralDevices >= 2)
02304                 {
02305                         ucInfo[3] = pInfo->aPeripheralDevice[1].ucPDType;
02306                         ucInfo[4] = pInfo->aPeripheralDevice[1].ucPDBusAdr;
02307                 }
02308                 if(pInfo->ucNoOfPeripheralDevices >= 3)
02309                 {
02310                         ucInfo[5] = pInfo->aPeripheralDevice[2].ucPDType;
02311                         ucInfo[6] = pInfo->aPeripheralDevice[2].ucPDBusAdr;
02312                 }
02313         }
02314 
02315         sReport += "Peripheral Devices";
02316         sReport += "\r\n";
02317 
02318         sReport += "\tNumber of Devices:.....";
02319         sprintf(cBuffer, "%d", ucInfo[0]);
02320         sReport += cBuffer;
02321         sReport += "\r\n";
02322 
02323         for(unsigned char ucCnt=0; ucCnt<ucInfo[0]; ucCnt++)
02324         {
02325                 sprintf(cBuffer, "\t%d. Device:.............", ucCnt+1);
02326                 sReport += cBuffer;
02327                 switch(ucInfo[1+2*ucCnt])
02328                 {
02329                 case FEDM_ISC_PD_TYPE_PEOPLE_COUNTER:
02330                         sReport += "People Counter";
02331                         break;
02332                 case FEDM_ISC_PD_TYPE_EXTERNAL_IO:
02333                         sReport += "External I/O-Board";
02334                         break;
02335                 }
02336                 sReport += "\r\n";
02337 
02338                 sprintf(cBuffer, "\t   Bus-Address:........", ucCnt);
02339                 sReport += cBuffer;
02340                 sprintf(cBuffer, "%d", ucInfo[2+2*ucCnt]);
02341                 sReport += cBuffer;
02342                 sReport += "\r\n";
02343         }
02344 #endif
02345 }
02346 
02347 
02348 void FedmIscReport_ReaderInfo::Add0x80InfoText(string& sReport, bool bSingle)
02349 {
02350         char cBuffer[64];
02351         unsigned char ucVersion[30];
02352         unsigned long nDeviceID = 0;
02353         string  sDeviceID;
02354         string  sOldCusID;
02355         string  sOldFWVersion;
02356         string  sOldRdrFunction;
02357         string  sOldTrDriver;
02358         string  sOldUhfRdrFunction;
02359         string  sOldUhfTrDriver;
02360         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02361 
02362         if(bSingle)
02363         {
02364                 m_pReader->GetData(FEDM_GetAdrOfID(FEDM_ISC_TMP_READER_INFO, 32), &ucVersion[0], 30, FEDM_TMPDATA_MEM);
02365         }
02366         else
02367         {
02368                 memcpy(&ucVersion[ 0], pInfo->ucRfcDevID, 4);
02369                 memcpy(&ucVersion[ 4], pInfo->ucRfcLicenseCustom, 4);
02370                 memcpy(&ucVersion[ 8], pInfo->ucRfcLicenseFw, 2);
02371                 memcpy(&ucVersion[10], pInfo->ucRfcLicenseTrType, 2);
02372                 memcpy(&ucVersion[12], pInfo->ucRfcLicenseFct, 2);
02373                 memcpy(&ucVersion[14], pInfo->ucRfcLicenseUhfTrType, 2);
02374                 memcpy(&ucVersion[16], pInfo->ucRfcLicenseUhfFct, 2);
02375         }
02376 
02377         FEDM_ConvHexUCharToHexStr(&ucVersion[ 0], 4, sDeviceID);
02378         FEDM_ConvHexUCharToHexStr(&ucVersion[ 4], 4, sOldCusID);
02379         FEDM_ConvHexUCharToHexStr(&ucVersion[ 8], 2, sOldFWVersion);
02380         FEDM_ConvHexUCharToHexStr(&ucVersion[10], 2, sOldTrDriver);
02381         FEDM_ConvHexUCharToHexStr(&ucVersion[12], 2, sOldRdrFunction);
02382         FEDM_ConvHexUCharToHexStr(&ucVersion[14], 2, sOldUhfTrDriver);
02383         FEDM_ConvHexUCharToHexStr(&ucVersion[16], 2, sOldUhfRdrFunction);
02384 
02385 
02386         sReport += "Serial Number and licensed options";
02387         sReport += "\r\n";
02388         sReport += "\tDevice-ID...............0x";
02389         sReport += sDeviceID;
02390         sReport += " (";
02391         sscanf(sDeviceID.c_str(), "%lx", &nDeviceID);
02392         sprintf(cBuffer, "%lu)", nDeviceID);
02393         sReport += cBuffer;
02394         sReport += "\r\n";
02395         sReport += "\tCustomer ID.............0x";
02396         sReport += sOldCusID;
02397         sReport += "\r\n";
02398         sReport += "\tFirmware Version........0x";
02399         sReport += sOldFWVersion;
02400 
02401         if(m_pReader->GetReaderType() == FEDM_ISC_TYPE_ISCPRHD102)
02402         {
02403                 sReport += "\r\n";
02404                 sReport += "\tHF-Transponder-Driver...0x";
02405                 sReport += sOldTrDriver;
02406                 sReport += "\r\n";
02407                 sReport += "\tHF Firmware Functions...0x";
02408                 sReport += sOldRdrFunction;
02409                 sReport += "\r\n";
02410                 sReport += "\tUHF-Transponder-Driver..0x";
02411                 sReport += sOldUhfTrDriver;
02412                 sReport += "\r\n";
02413                 sReport += "\tUHF Firmware Functions..0x";
02414                 sReport += sOldUhfRdrFunction;
02415         }
02416         else
02417         {
02418                 sReport += "\r\n";
02419                 sReport += "\tTransponder-Driver......0x";
02420                 sReport += sOldTrDriver;
02421                 sReport += "\r\n";
02422                 sReport += "\tFirmware Functions......0x";
02423                 sReport += sOldRdrFunction;
02424                 switch(m_pReader->GetReaderType())
02425                 {
02426                 case FEDM_ISC_TYPE_ISCLRU3000:
02427                         if(ucVersion[13] & 0x01)
02428                         {
02429                                 // ISO 18000-6-C 
02430                                 sReport += " (with ISO 18000-6-C support)";
02431                         }
02432                         break;
02433                 }
02434         }
02435 
02436 /*      if( pInfo->bIsRfcFrequency)
02437         {
02438                 switch(m_pReader->GetReaderType())
02439                 {
02440                 case FEDM_ISC_TYPE_ISCMU02:
02441                 case FEDM_ISC_TYPE_ISCLRU1000:
02442                 case FEDM_ISC_TYPE_ISCLRU2000:
02443                 case FEDM_ISC_TYPE_ISCLRU3000:
02444                         sReport += "\r\n";
02445                         sReport += "\tFrequency Information:..";
02446                         if((ucVersion[6]&0x03) == 1)
02447                                 sReport += "EU";
02448                         else if((ucVersion[6]&0x03) == 2)
02449                                 sReport += "FCC";
02450                         else if((ucVersion[6]&0x03) == 3)
02451                                 sReport += "EU and FCC";
02452                         else
02453                                 sReport += "unknown";
02454 
02455                         break;
02456 
02457                 case FEDM_ISC_TYPE_ISCPRHD102:
02458                         sReport += "\r\n";
02459                         sReport += "\tHF-Drivers:.............";
02460                         if((ucVersion[6]&0x80))
02461                                 sReport += "enabled";
02462                         else
02463                                 sReport += "disabled";
02464 
02465                         sReport += "\r\n";
02466                         sReport += "\tUHF-Drivers:............";
02467                         if((ucVersion[6]&0x40))
02468                                 sReport += "enabled";
02469                         else
02470                                 sReport += "disabled";
02471 
02472                         break;
02473 
02474                 } // switch(m_pReader->GetReaderType())
02475 
02476         } // if( pInfo->bIsRfcFrequency)*/
02477 
02478         sReport += "\r\n";
02479 }
02480 
02481 void FedmIscReport_ReaderInfo::AddAllInfoText(string& sReport)
02482 {
02483         FEDM_ISC_READER_INFO* pInfo = m_pReader->GetReaderInfo();
02484 
02485         if(pInfo->bIsMode0x00Read)
02486                 Add0x00InfoText(sReport, false);
02487 
02488         if(pInfo->bIsMode0x01Read)
02489         {
02490                 sReport += "\n";//\n";
02491                 Add0x01InfoText(sReport, false);
02492         }
02493 
02494         if(pInfo->bIsMode0x02Read)
02495         {
02496                 sReport += "\n";//\n";
02497                 Add0x02InfoText(sReport, false);
02498         }
02499 
02500         if(pInfo->bIsMode0x03Read)
02501         {
02502                 sReport += "\n";//\n";
02503                 Add0x03InfoText(sReport, false);
02504         }
02505 
02506         if(pInfo->bIsMode0x04Read)
02507         {
02508                 sReport += "\n";//\n";
02509                 Add0x04InfoText(sReport, false);
02510         }
02511 
02512         if(pInfo->bIsMode0x05Read)
02513         {
02514                 sReport += "\n";//\n";
02515                 Add0x05InfoText(sReport, false);
02516         }
02517 
02518         if(pInfo->bIsMode0x06Read)
02519         {
02520                 sReport += "\n";//\n";
02521                 Add0x06InfoText(sReport, false);
02522         }
02523 
02524         if(pInfo->bIsMode0x07Read)
02525         {
02526                 sReport += "\n";//\n";
02527                 Add0x07InfoText(sReport, false);
02528         }
02529 
02530         if(pInfo->bIsMode0x08Read)
02531         {
02532                 sReport += "\n";//\n";
02533                 Add0x08InfoText(sReport, false);
02534         }
02535 
02536         if(pInfo->bIsMode0x09Read)
02537         {
02538                 sReport += "\n";//\n";
02539                 Add0x09InfoText(sReport, false);
02540         }
02541 
02542         if(pInfo->bIsMode0x10Read)
02543         {
02544                 sReport += "\n";//\n";
02545                 Add0x10InfoText(sReport, false);
02546         }
02547 
02548         if(pInfo->bIsMode0x11Read)
02549         {
02550                 sReport += "\n";//\n";
02551                 Add0x11InfoText(sReport, false);
02552         }
02553 
02554         if(pInfo->bIsMode0x12Read)
02555         {
02556                 sReport += "\n";//\n";
02557                 Add0x12InfoText(sReport, false);
02558         }
02559 
02560         if(pInfo->bIsMode0x40Read)
02561         {
02562                 sReport += "\n";//\n";
02563                 Add0x40InfoText(sReport, false);
02564         }
02565 
02566         if(pInfo->bIsMode0x41Read)
02567         {
02568                 sReport += "\n";//\n";
02569                 Add0x41InfoText(sReport, false);
02570         }
02571 
02572         if(     pInfo->bIsMode0x50Read ||
02573                 pInfo->bIsMode0x51Read ||
02574                 pInfo->bIsMode0x52Read ||
02575                 pInfo->bIsMode0x53Read )
02576         {
02577                 sReport += "\n";//\n";
02578                 sReport += "LAN-Information\n";
02579         }
02580 
02581         if(pInfo->bIsMode0x50Read)
02582                 Add0x50InfoText(sReport, false);
02583 
02584         if( (pInfo->ucLanFlags & ((pInfo->ucLanFlags&0x03)<<2) ) == 0 ) // IPv4 and/or IPv6 not disabled
02585         {
02586                 if(pInfo->bIsMode0x51Read)
02587                         Add0x51InfoText(sReport, false);
02588 
02589                 if(pInfo->bIsMode0x52Read)
02590                         Add0x52InfoText(sReport, false);
02591 
02592                 if(pInfo->bIsMode0x53Read)
02593                         Add0x53InfoText(sReport, false);
02594         }
02595 
02596         if(     pInfo->bIsMode0x54Read ||
02597                 pInfo->bIsMode0x55Read ||
02598                 pInfo->bIsMode0x56Read ||
02599                 pInfo->bIsMode0x57Read )
02600         {
02601                 sReport += "\n";//\n";
02602                 sReport += "WLAN-Information\n";
02603         }
02604 
02605         if(pInfo->bIsMode0x54Read)
02606                 Add0x54InfoText(sReport, false);
02607 
02608 //      if(pInfo->ucWlanFlags & 0x03) // IPv4 or IPv6 supported
02609         if( (pInfo->ucWlanFlags & ((pInfo->ucWlanFlags&0x03)<<2) ) == 0 ) // IPv4 and/or IPv6 not disabled
02610         {
02611                 if(pInfo->bIsMode0x55Read)
02612                         Add0x55InfoText(sReport, false);
02613 
02614                 if(pInfo->bIsMode0x56Read)
02615                         Add0x56InfoText(sReport, false);
02616 
02617                 if(pInfo->bIsMode0x57Read)
02618                         Add0x57InfoText(sReport, false);
02619         }
02620 
02621         if(pInfo->bIsMode0x60Read)
02622         {
02623                 sReport += "\n";//\n";
02624                 Add0x60InfoText(sReport, false);
02625         }
02626 
02627         if(pInfo->bIsMode0x61Read)
02628         {
02629                 sReport += "\n";//\n";
02630                 Add0x61InfoText(sReport, false);
02631         }
02632 
02633         if(pInfo->bIsMode0x80Read)
02634         {
02635                 sReport += "\n";//\n";
02636                 Add0x80InfoText(sReport, false);
02637         }
02638 }


rfid_drivers
Author(s): Raul Perula-Martinez
autogenerated on Thu Apr 2 2015 03:06:13