home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 2000 April / VPR0004B.BIN / DRIVER / COMPAQ / SP12255 / sp12255.exe / DMWEBC1.CAB / HARDDISK.TPL < prev    next >
Text File  |  1999-06-22  |  16KB  |  539 lines
  1. <HTML>
  2. <!-- $Id -->
  3. <!-- Copyright (C) 1997 Compaq Computer Corporation -->
  4.  
  5. <HEAD>
  6.  
  7. <!#IDEDEV.JS>
  8. <!#SCSIDEV.JS>
  9. <!#FLOPPY.JS>
  10.  
  11. <SCRIPT LANGUAGE="JavaScript">
  12.  
  13. <!#TABLES.JS>
  14. <!#COND.JS>
  15.  
  16. </SCRIPT>
  17. </HEAD>
  18.  
  19.  
  20. <SCRIPT LANGUAGE="JavaScript">
  21.  
  22. <!*, DMTF|Disks|*, 1, dmiStorageType>
  23. <!*, DMTF|Disks|*, 2, dmiDevIndex>
  24. <!*, DMTF|Disks|*, 3, dmiDevIntfType>
  25. <!*, DMTF|Disks|*, 4, dmiDevDesc>
  26. <!*, DMTF|Disks|*, 6, dmiDriveRemovable>
  27. <!*, DMTF|Disks|*, 7, dmiMediaRemovable>
  28. <!*, DMTF|Disks|*, 10, dmiNumCyl>
  29. <!*, DMTF|Disks|*, 11, dmiNumSect>
  30. <!*, DMTF|Disks|*, 12, dmiNumHeads>
  31. <!*, DMTF|Disks|*, 15, dmiSectorSize>
  32. <!*, DMTF|Disks|*, 16, dmiTotalSize>
  33. <!*, DMTF|Disks|*, 17, dmiNumBadSector>
  34. <!*, DMTF|Disks|*, 18, dmiNumPartition>
  35. <!*, DMTF|Disks|*, 20, DiskFRUIndex>
  36. <!*, DMTF|Disks|*, 21, DiskOsIndex>
  37.  
  38. <!*, DMTF|FRU|*, 1, FRUIndex>
  39. <!*, DMTF|FRU|*, 5, Model>
  40. <!*, DMTF|FRU|*, 7, SerialNumber>
  41. <!*, DMTF|FRU|*, 8, RevisionLevel>
  42.  
  43. <!*, DMTF|Logical Drives|*, 3, dmiDriveType>
  44.  
  45. <!*, DMTF|Operational State|*, 1, OsIndex>
  46. <!*, DMTF|Operational State|*, 10, OsCurrentErrorStatus>
  47.  
  48.     DiskStatus = new Array();
  49.     DiskStatus[0] = "Other";
  50.     DiskStatus[1] = "Unknown";
  51.     DiskStatus[2] = "OK";
  52.     DiskStatus[3] = "Non-critical";
  53.     DiskStatus[4] = "Critical";
  54.     DiskStatus[5] = "Non-recoverable";
  55.     deviceId = 0;
  56.  
  57.     // Display Storage Devices info
  58.     for ( i = 0; i < dmiDevIndex.length; i++)
  59.         {
  60.         if (dmiDevIntfType[i] == "Floppy Disk Interface" || dmiDriveType[i] == "Floppy Drive")
  61.         {
  62.             Floppy();
  63.             break;
  64.         }
  65.     }
  66.  
  67.     for ( i = 0; i < dmiDevIndex.length; i++)
  68.         {
  69.         if (dmiStorageType[i] == "Compact Disk" && dmiDevIntfType[i] != "SCSI" && dmiDevIntfType[i] != "IDE" && dmiDevIntfType[i] != "Enhanced ATA/IDE")
  70.         {
  71.             CompactDisk();
  72.             break;
  73.         }
  74.     }
  75.  
  76.     for ( i = 0; i < dmiDevIndex.length; i++)
  77.         {
  78.         if (dmiStorageType[i] == "Hard Disk" && dmiDevIntfType[i] != "SCSI" && dmiDevIntfType[i] != "IDE" && dmiDevIntfType[i] != "Enhanced ATA/IDE")
  79.         {
  80.             HardDrive();
  81.             break;
  82.         }
  83.     }
  84.  
  85.     for ( i = 0; i < dmiDevIndex.length; i++)
  86.         {
  87.         if (dmiDevIntfType[i] == "IDE" || dmiDevIntfType[i] == "Enhanced ATA/IDE")
  88.         {
  89.                  IDE();
  90.             break;
  91.         }
  92.     }
  93.  
  94.     for ( i = 0; i < dmiDevIndex.length; i++)
  95.         {
  96.         if (dmiDevIntfType[i] == "SCSI")
  97.         {
  98.             SCSI();
  99.             break;
  100.         }
  101.     }
  102.  
  103.  
  104. function HardDrive()
  105. {
  106.     deviceId = 1;
  107.  
  108.     for ( i = 0; i < dmiDevIndex.length; i++)
  109.         {
  110.         if (dmiStorageType[i] == "Hard Disk" && dmiDevIntfType[i] != "SCSI" && dmiDevIntfType[i] != "IDE" && dmiDevIntfType[i] != "Enhanced ATA/IDE")
  111.         {
  112.             deviceId = deviceId + 1;
  113.             tableCap = "Hard Disk Information - " + deviceId;
  114.  
  115.             deviceCond = new cpqCondition(1);
  116.             if (DiskOsIndex[i] > 0)
  117.             {
  118.                 ActualOsIndex = -1;
  119.                 for (k = 0; k < OsIndex.length; k++)
  120.                 {
  121.                     if (DiskOsIndex[i] == OsIndex[k])
  122.                     {
  123.                         ActualOsIndex = k;
  124.                         break;
  125.                     }
  126.                 }
  127.                 if (ActualOsIndex >= 0)
  128.                 {
  129.                     for (j = 0; j <= DiskStatus.length - 1; j++)
  130.                     {
  131.                         if (OsCurrentErrorStatus[ActualOsIndex] == DiskStatus[j])
  132.                         {
  133.                                  if (j == 5)
  134.                                              deviceCond = new cpqCondition(4);
  135.                                  else if (j == 3 || j == 4)
  136.                                              deviceCond = new cpqCondition(3);
  137.                                  else if (j == 2)
  138.                                              deviceCond = new cpqCondition(2);
  139.                                  else if (j < 2)
  140.                                              deviceCond = new cpqCondition(1);
  141.                             break;
  142.                         }
  143.                            }
  144.                 }
  145.             }
  146. //            tableCap = deviceCond.image() + tableCap;
  147.  
  148.             writeTableLabel( tableCap, "" );
  149.             writeTableHead();
  150.  
  151.             writeSingleTableRowOrBlank(  deviceCond.imageSmall() + " " + sDriveIndex + ":", dmiDevIndex[i]);
  152.             writeSingleTableRowOrBlank( "Storage Type:", dmiStorageType[i]);
  153.             writeSingleTableRowOrBlank( "Interface Type:", dmiDevIntfType[i]);
  154.             writeSingleTableRowOrBlank( "Interface Description:", dmiDevDesc[i]);
  155.             writeSingleTableRowOrBlank( "Removable Drive:", dmiDriveRemovable[i]);
  156.             writeSingleTableRowOrBlank( "Removable Media:", dmiMediaRemovable[i]);
  157.             writeSingleTableRowOrBlank( "Number of Physical Cylinders:", dmiNumCyl[i]);
  158.             writeSingleTableRowOrBlank( "Number of Physical Sectors:", dmiNumSect[i]);
  159.             writeSingleTableRowOrBlank( "Number of Physical Heads:", dmiNumHeads[i]);
  160.             writeSingleTableRowOrBlank( "Sector Size:", dmiSectorSize[i] + " Bytes");
  161.                      writeSingleTableRowOrBlank( "Total Physical Size:", Math.round((dmiTotalSize[i]/1024/1024) * 100)/100 + " GB");
  162.             writeSingleTableRowOrBlank( "Current Bad Blocks or Sectors:", dmiNumBadSector[i]);
  163.             writeSingleTableRowOrBlank( "Partitions:", dmiNumPartition[i]);
  164.  
  165.             if (DiskFRUIndex[i] > 0)
  166.             {
  167.                 ActualFRUIndex = -1;
  168.                 for (k = 0; k < FRUIndex.length; k++)
  169.                 {
  170.                     if (DiskFRUIndex[i] == FRUIndex[k])
  171.                     {
  172.                         ActualFRUIndex = k;
  173.                         break;
  174.                     }
  175.                 }
  176.                 if (ActualFRUIndex >= 0)
  177.                 {
  178.                           writeSingleTableRowOrBlank( "Model:", Model[ActualFRUIndex]);
  179.                           writeSingleTableRowOrBlank( "Serial Number:", SerialNumber[ActualFRUIndex]);
  180.                           writeSingleTableRowOrBlank( "Firmware Version:", RevisionLevel[ActualFRUIndex]);
  181.                 }
  182.             }
  183.             else
  184.             {
  185.                   writeSingleTableRow( "Model:",  "");
  186.                   writeSingleTableRow( "Serial Number:", "");
  187.                   writeSingleTableRow( "Firmware Version:", "");
  188.             }
  189.       
  190.                   if (i < dmiDevIndex.length - 1)
  191.                     writeSingleTableRow(" ", " ");
  192.         }
  193.     
  194.          }
  195.     writeTableTail();
  196.     document.write("<BR>");
  197. }
  198.  
  199. function IDE()
  200. {
  201.     deviceId = 1;
  202.  
  203.     for(i = 0; i < dmiDevIndex.length; i++)
  204.     {
  205.         if (dmiDevIntfType[i] == "IDE" || dmiDevIntfType[i] == "Enhanced ATA/IDE")
  206.         {
  207.             tableCap = sIDEDevice + " " + deviceId;
  208.     
  209.             deviceCond = new cpqCondition(1);
  210.             diskAction = diskActionText[1];
  211.             if (DiskOsIndex[i] > 0)
  212.             {
  213.                 ActualOsIndex = -1;
  214.                 for (k = 0; k < OsIndex.length; k++)
  215.                 {
  216.                     if (DiskOsIndex[i] == OsIndex[k])
  217.                     {
  218.                         ActualOsIndex = k;
  219.                         break;
  220.                     }
  221.                 }
  222.                 if (ActualOsIndex >= 0)
  223.                 {
  224.                            for (j = 0; j <= DiskStatus.length - 1; j++)
  225.                     {
  226.                         if (OsCurrentErrorStatus[ActualOsIndex] == DiskStatus[j])
  227.                         {
  228.                                  if (j == 5)
  229.                                            finalStatusIndex = 4;
  230.                                  else if (j == 3 || j == 4)
  231.                                            finalStatusIndex = 3;
  232.                                  else if (j == 2)
  233.                                            finalStatusIndex = 2;
  234.                             else if (j < 2)
  235.                                            finalStatusIndex = 1;
  236.                                        deviceCond = new cpqCondition(finalStatusIndex);
  237.                             diskAction = diskActionText[finalStatusIndex];
  238.                             break;
  239.                         }
  240.                            }
  241.                 }
  242.             }
  243. //                tableCap = deviceCond.image() + tableCap;
  244.  
  245.                 writeTableLabel( tableCap, sIDEDeviceDetails);
  246.     
  247.                 writeTableHead();
  248.  
  249.             writeSingleTableRowOrBlank( deviceCond.imageSmall() + " " + sDriveIndex + ":", dmiDevIndex[i]);
  250.                 if (DiskFRUIndex[i] > 0)
  251.                 {
  252.                 ActualFRUIndex = -1;
  253.                 for (k = 0; k < FRUIndex.length; k++)
  254.                 {
  255.                     if (DiskFRUIndex[i] == FRUIndex[k])
  256.                     {
  257.                         ActualFRUIndex = k;
  258.                         break;
  259.                     }
  260.                 }
  261.                 if (ActualFRUIndex >= 0)
  262.                 {
  263.                           writeSingleTableRowOrBlank( sModel + ":", Model[ActualFRUIndex]);
  264.                           writeSingleTableRowOrBlank( sSerialNumber + ":", SerialNumber[ActualFRUIndex]);
  265.                           writeSingleTableRowOrBlank( sFirmwareVersion + ":", RevisionLevel[ActualFRUIndex]);
  266.                 }
  267.                 }
  268.                 else
  269.                 {
  270.                       writeSingleTableRow( sModel + ":",  "");
  271.                       writeSingleTableRow( sSerialNumber + ":", "");
  272.                       writeSingleTableRow( sFirmwareVersion + ":", "");
  273.             }
  274.             writeSingleTableRowOrBlank( sDeviceType + ":", dmiStorageType[i]);
  275. //                writeSingleTableRowOrBlank( "Removable Media:", dmiMediaRemovable[i]);
  276. //                 writeSingleTableRowOrBlank( "Media Present:", dmiMediaLoaded[i]);
  277.  
  278.             if (dmiStorageType[i] != "Compact Disk")
  279.             {
  280.                          writeSingleTableRowOrBlank( sCapacity + ":", Math.round((dmiTotalSize[i]/1024/1024) * 100)/100 + " GB");
  281.                          writeSingleTableRowOrBlank( sHeads + ":", dmiNumHeads[i]);
  282.                          writeSingleTableRowOrBlank( sCylinders + ":", dmiNumCyl[i]);
  283.                          writeSingleTableRowOrBlank( sSectorsperTrack + ":", dmiNumSect[i]);
  284.             }
  285.  
  286.                 <!-- ==================== ACTION ==================== -->
  287.             writeSingleTableRowOrBlank( "", " ");
  288.             writeSingleTableRowOrBlank(sAction + ":", diskAction);
  289.                 <!-- ================================================ -->
  290.             deviceId = deviceId + 1;
  291.         }
  292.     }
  293.     writeTableTail();
  294.     document.write("<BR>");
  295. }
  296.  
  297. function SCSI()
  298. {
  299.     deviceId = 0;
  300.  
  301.     for ( i = 0; i < dmiDevIndex.length; i++)
  302.         {
  303.         if (dmiDevIntfType[i] == "SCSI")
  304.         {
  305.             deviceId = deviceId + 1;
  306.             tableCap = sSCSIDriveInformation + deviceId;
  307.  
  308.             finalStatusIndex = 1;
  309.             deviceCond = new cpqCondition(finalStatusIndex);
  310.             if (DiskOsIndex[i] > 0)
  311.             {
  312.                 ActualOsIndex = -1;
  313.                 for (k = 0; k < OsIndex.length; k++)
  314.                 {
  315.                     if (DiskOsIndex[i] == OsIndex[k])
  316.                     {
  317.                         ActualOsIndex = k;
  318.                         break;
  319.                     }
  320.                 }
  321.                 if (ActualOsIndex >= 0)
  322.                 {
  323.                     for (j = 0; j <= DiskStatus.length - 1; j++)
  324.                     {
  325.                         if (OsCurrentErrorStatus[ActualOsIndex] == DiskStatus[j])
  326.                         {
  327.                                  if (j == 5)
  328.                                 finalStatusIndex = 4;
  329.                                  else if (j == 3 || j == 4)
  330.                                 finalStatusIndex = 3;
  331.                                  else if (j == 2)
  332.                                 finalStatusIndex = 2;
  333.                                  else if (j < 2)
  334.                                 finalStatusIndex = 1;
  335.                                          deviceCond = new cpqCondition(finalStatusIndex);
  336.                             break;
  337.                         }
  338.                            }
  339.                 }
  340.             }
  341. //            tableCap = deviceCond.image() + tableCap;
  342.  
  343.             writeTableLabel( tableCap, "" );
  344.             writeTableHead();
  345.  
  346.             writeSingleTableRowOrBlank(  deviceCond.imageSmall() + " " + sDriveIndex + ":", dmiDevIndex[i]);
  347.             writeSingleTableRowOrBlank( sStorageType + ":", dmiStorageType[i]);
  348.             writeSingleTableRowOrBlank( sInterfaceDescription + ":", dmiDevDesc[i]);
  349.             writeSingleTableRowOrBlank( sRemovableDrive + ":", dmiDriveRemovable[i]);
  350.             writeSingleTableRowOrBlank( sRemovableMedia + ":", dmiMediaRemovable[i]);
  351.             writeSingleTableRowOrBlank( sNumCyl + ":", dmiNumCyl[i]);
  352.             writeSingleTableRowOrBlank( sNumSec + ":", dmiNumSect[i]);
  353.             writeSingleTableRowOrBlank( sNumHeads + ":", dmiNumHeads[i]);
  354.             writeSingleTableRowOrBlank( sSectorSize + ":", dmiSectorSize[i] + " Bytes");
  355.                      writeSingleTableRowOrBlank( sTotalPhysicalSize + ":", Math.round((dmiTotalSize[i]/1024/1024) * 100)/100 + " GB");
  356.             writeSingleTableRowOrBlank( sBadBlockOrSector + ":", dmiNumBadSector[i]);
  357.             writeSingleTableRowOrBlank( sPartitions + ":", dmiNumPartition[i]);
  358.  
  359.             if (DiskFRUIndex[i] > 0)
  360.             {
  361.                 ActualFRUIndex = -1;
  362.                 for (k = 0; k < FRUIndex.length; k++)
  363.                 {
  364.                     if (DiskFRUIndex[i] == FRUIndex[k])
  365.                     {
  366.                         ActualFRUIndex = k;
  367.                         break;
  368.                     }
  369.                 }
  370.                 if (ActualFRUIndex >= 0)
  371.                 {
  372.                           writeSingleTableRowOrBlank( sModel + ":", Model[ActualFRUIndex]);
  373.                           writeSingleTableRowOrBlank( sSerialNumber + ":", SerialNumber[ActualFRUIndex]);
  374.                           writeSingleTableRowOrBlank( sFirmwareVersion + ":", RevisionLevel[ActualFRUIndex]);
  375.                 }
  376.             }
  377.             else
  378.             {
  379.                   writeSingleTableRow( sModel + ":",  "");
  380.                   writeSingleTableRow( sSerialNumber + ":", "");
  381.                   writeSingleTableRow( sFirmwareVersion + ":", "");
  382.             }
  383.  
  384.       
  385.                   if (i < dmiDevIndex.length - 1)
  386.                     writeSingleTableRow(" ", " ");
  387.  
  388.             writeSingleTableRowOrBlank( "", " ");
  389.             writeSingleTableRowOrBlank(sAction + ":", diskAction = diskActionText[finalStatusIndex]);
  390.         }
  391.     }
  392.     writeTableTail();
  393.     document.write("<BR>");
  394. }
  395.  
  396. function Floppy()
  397. {
  398. <!*, DMTF|Logical Drives|*, 2, dmiDriveName>
  399. <!*, DMTF|Logical Drives|*, 3, dmiDriveType>
  400. <!*, DMTF|Logical Drives|*, 4, dmiDriveSize>
  401.  
  402.       writeTableLabel(sDiskette + " " + sDrive + " " + sInfo);
  403.       writeTableHead();
  404.  
  405.     writeColumnTableHeaderRow(sDrive, sType);
  406.  
  407.     DriveLabel = ""
  408.     for ( i = 0; i < dmiDriveName.length; i++)
  409.     {
  410.         DriveLabel = dmiDriveName[i].substring(0, 1);
  411.         DriveLabel = DriveLabel.toUpperCase();
  412.     if (dmiDriveType[i] == "Floppy Drive" || DriveLabel == "A" || DriveLabel == "B")
  413.     {
  414.         if (dmiDriveSize[i] == "360")
  415.             writeColumnTableDataRow( dmiDriveName[i], "360K (5.25 inch)");
  416.         else
  417.             if (dmiDriveSize[i] == "720")
  418.                 writeColumnTableDataRow( dmiDriveName[i], "720K (3.5 inch)");
  419.             else
  420.                 if (dmiDriveSize[i] == "1228")
  421.                     writeColumnTableDataRow( dmiDriveName[i], "1.2 Megabyte (5.25 inch)");
  422.                 else
  423.                     if (dmiDriveSize[i] == "1423")
  424.                         writeColumnTableDataRow( dmiDriveName[i], "1.44 Megabyte (3.5 inch)");
  425.                     else
  426.                         if (dmiDriveSize[i] == 123006)
  427.                             writeColumnTableDataRow( dmiDriveName[i], "120 Megabyte (3.5 inch)");
  428.                         else
  429.                             writeColumnTableDataRow( dmiDriveName[i], "Unknown");
  430.     }
  431.     }
  432.      
  433.     writeTableTail();
  434.     document.write("<BR>");
  435. }
  436.  
  437. function CompactDisk()
  438. {
  439.     deviceId = 1;
  440.  
  441.     for(i = 0; i < dmiDevIndex.length; i++)
  442.     {
  443.         if (dmiStorageType[i] == "Compact Disk" && dmiDevIntfType[i] != "SCSI" && dmiDevIntfType[i] != "IDE" && dmiDevIntfType[i] != "Enhanced ATA/IDE")
  444.         {
  445.             tableCap = sCompactDisk + " " + deviceId;
  446.     
  447.             deviceCond = new cpqCondition(1);
  448.             diskAction = diskActionText[1];
  449.             if (DiskOsIndex[i] > 0)
  450.             {
  451.                 ActualOsIndex = -1;
  452.                 for (k = 0; k < OsIndex.length; k++)
  453.                 {
  454.                     if (DiskOsIndex[i] == OsIndex[k])
  455.                     {
  456.                         ActualOsIndex = k;
  457.                         break;
  458.                     }
  459.                 }
  460.                 if (ActualOsIndex >= 0)
  461.                 {
  462.                            for (j = 0; j <= DiskStatus.length - 1; j++)
  463.                     {
  464.                         if (OsCurrentErrorStatus[ActualOsIndex] == DiskStatus[j])
  465.                         {
  466.                                  if (j == 5)
  467.                                            finalStatusIndex = 4;
  468.                                  else if (j == 3 || j == 4)
  469.                                            finalStatusIndex = 3;
  470.                                  else if (j == 2)
  471.                                            finalStatusIndex = 2;
  472.                             else if (j < 2)
  473.                                            finalStatusIndex = 1;
  474.                                        deviceCond = new cpqCondition(finalStatusIndex);
  475.                             diskAction = diskActionText[finalStatusIndex];
  476.                             break;
  477.                         }
  478.                            }
  479.                 }
  480.             }
  481. //                tableCap = deviceCond.image() + tableCap;
  482.  
  483.                 writeTableLabel( tableCap, "");
  484.     
  485.                 writeTableHead();
  486.  
  487.             writeSingleTableRowOrBlank( deviceCond.imageSmall() + " " + sDriveIndex + ":", dmiDevIndex[i]);
  488.                 if (DiskFRUIndex[i] > 0)
  489.                 {
  490.                 ActualFRUIndex = -1;
  491.                 for (k = 0; k < FRUIndex.length; k++)
  492.                 {
  493.                     if (DiskFRUIndex[i] == FRUIndex[k])
  494.                     {
  495.                         ActualFRUIndex = k;
  496.                         break;
  497.                     }
  498.                 }
  499.                 if (ActualFRUIndex >= 0)
  500.                 {
  501.                           writeSingleTableRowOrBlank( sModel + ":", Model[ActualFRUIndex]);
  502.                           writeSingleTableRowOrBlank( sSerialNumber + ":", SerialNumber[ActualFRUIndex]);
  503.                           writeSingleTableRowOrBlank( sFirmwareVersion + ":", RevisionLevel[ActualFRUIndex]);
  504.                 }
  505.                 }
  506.                 else
  507.                 {
  508.                       writeSingleTableRow( sModel + ":",  "");
  509.                       writeSingleTableRow( sSerialNumber + ":", "");
  510.                       writeSingleTableRow( sFirmwareVersion + ":", "");
  511.             }
  512.             writeSingleTableRowOrBlank( sDeviceType + ":", dmiStorageType[i]);
  513. //                writeSingleTableRowOrBlank( "Removable Media:", dmiMediaRemovable[i]);
  514. //                 writeSingleTableRowOrBlank( "Media Present:", dmiMediaLoaded[i]);
  515.  
  516.             if (dmiStorageType[i] != "Compact Disk")
  517.             {
  518.                          writeSingleTableRowOrBlank( sCapacity + ":", Math.round((dmiTotalSize[i]/1024/1024) * 100)/100 + " GB");
  519.                          writeSingleTableRowOrBlank( sHeads + ":", dmiNumHeads[i]);
  520.                          writeSingleTableRowOrBlank( sCylinders + ":", dmiNumCyl[i]);
  521.                          writeSingleTableRowOrBlank( sSectorsperTrack + ":", dmiNumSect[i]);
  522.             }
  523.  
  524.                 <!-- ==================== ACTION ==================== -->
  525.             writeSingleTableRowOrBlank( "", " ");
  526.             writeSingleTableRowOrBlank(sAction + ":", diskAction);
  527.                 <!-- ================================================ -->
  528.             deviceId = deviceId + 1;
  529.         }
  530.     }
  531.     writeTableTail();
  532.     document.write("<BR>");
  533. }
  534.  
  535.  
  536. </SCRIPT>
  537.  
  538. </HTML>
  539.