home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 26 / CD_ASCQ_26_1295.iso / vrac / fluke13.zip / FLUKECOM.ASP < prev    next >
Text File  |  1995-08-31  |  34KB  |  1,417 lines
  1. ; Simple program to allow one to take control of the Fluke Scopemeter 97.
  2. ; This source and all associated files are Copyright 1995 of John L. Groezinger.
  3. ; Comments may be sent to jlgroezinger@mmm.com
  4.  
  5. ; V1.0, 5/24/95, jlg, original version
  6.  
  7. ; V1.1, 6/22/95, jlg 
  8. ; added much more information in flukecom.hlp file
  9. ; added default of *.* to dir command
  10. ; fixed null write file problem when sending strings to a disk file with
  11. ; the fputs command to write binary data to disk.  Used the fwrite command.
  12. ; fixed a missing error message in makecsv to indicated if the .dat file
  13. ; did not have enough data in it. Added the init command. Moved the 
  14. ; version string to the header file.
  15.  
  16. ; V1.2, 6/30/95, jlg 
  17. ; fixed type in help file
  18. ; changed version string
  19. ; removed extraneous code from getmeter in flukeint.asp
  20. ; speeded up the autobaud procedure significantly
  21. ; added optional parameter to timestamp command to timestamp to a file
  22. ; added additional documentation to makecsv
  23. ; changed error returns in makecsv to 1 for error, 0 for ok
  24. ; put some minor tweaks in getmeter to (hopefully) inmprove speed (sub'd
  25. ; key2ascii for strfmt)
  26. ; added the get/put <filename> command to get/save current configuration
  27. ; added the profile.mac feature
  28.  
  29. ; V1.3, 8/30/95, jlg
  30. ; found bug in the get_array routine, would not operate correctly if data
  31. ; was null.
  32.  
  33. ; Notes for future improvements:
  34. ;
  35. ; 1) Could do further attempts at serial connections including additional
  36. ; baud rates, attempts with nonzero ack connection, parity enabled, and
  37. ; 7 data bits, xon/xoff.
  38. ;
  39. ; 2) Add features to store currently used values which have been modified
  40. ; as part of the initialization sequence. Guess again, if we have space
  41. ; this requires the use of storing the variables and using this to send
  42. ; the commands, you cannot just use the variables as part of the setup
  43. ; sequence,     if (init_aspdebug)
  44. ;            set aspdebug on
  45. ;        else
  46. ;            set aspdebug off
  47. ;        endif
  48. ; Create a read and write file function which would allow you to save and
  49. ; restore the current settings of pcplus to a file and then use a case
  50. ; switch statement to parse out the resulting savings to restore the 
  51. ; current configuration.
  52. ;
  53. ; 3) Should increase error checking on number of parameters, for instance
  54. ; additional parameters on copy command are simply ignored, should be parsed
  55. ; and complained about.  But then again, this is handy for comments....
  56. ;
  57. ; 4) Add setup and restore setup functions to meter much more gracefully
  58. ; than the current numeric.
  59. ;
  60. ; 5) A filename which is entered which is too long is simply truncated
  61. ; with no error indication
  62. ; 
  63. ; 6) The check_range routine can easily be fooled by putting in any
  64. ; nonnumeric value, it will return zero.  This is also true about the ifgoto
  65. ; command which will use a non-numeric or non-present value as zero
  66. ;
  67. ; 7) Break script up into several subscripts which use up less at a time
  68. ; 
  69. ; 9) one could envision several extensions to this which would include
  70. ; a more sophisticated loop capability (additional loops or labels) and
  71. ; shell variables.  We'll see.....
  72. ;
  73. ; 10) if a disk write error occurs and disk logging is occuring, then 
  74. ; the user will get two write errors, once for the command and a second for 
  75. ; the disk log.
  76. ;
  77. ; 11) Look into ways to reduce the time to read from meter to PC
  78. ;
  79. ; 12) Put common routines in a header file.  However, when I tried this,
  80. ; I got runtime errors.
  81.  
  82. ; globals
  83.  
  84. string    bigresp1        ; all the waveform response strings
  85. string    bigresp2,bigresp3,bigresp4,bigresp5,bigresp6,bigresp7
  86. integer    bigpointer        ; pointer into string
  87. integer    bigstring        ; which string
  88.  
  89. integer    macroflag        ; indicates if in macro mode or not
  90. long    macropos        ; current location in macro file for loop
  91. integer    logflag            ; is logging on?
  92.  
  93. ; values from meter structure
  94. string id,yunit,xunit        ; channel name, x and y units
  95. float yzero,xzero,ydelta,xdelta ; scale information
  96. integer ylevel,xsample        ; number points and resolution
  97.  
  98. ; user string is left here in parsed out form
  99. string cmd1,cmd2,cmd3,cmd4
  100.  
  101. include "flukecom.h"
  102.  
  103. proc main
  104.     integer reterror
  105.     string retstr
  106.     string tmpstr
  107.     integer tmplen        ; temp variable 
  108.     integer hourwait, minwait ; for clock function
  109.     float readvalue        ; value from last read operation
  110.     float mingoto, maxgoto    ; current tests for ifgoto command
  111.     long looppos        ; location to loop back to for loop 
  112.     long loopcount        ; current count in loop
  113.     long tmplong        ; used for whatever
  114.     integer retack, terminator ; used for "put" command
  115.  
  116.     looppos = 0        ; always start loop at zero
  117.     readvalue = 0.0        ; read is at zero
  118.     macroflag = 0
  119.     logflag = 0        ; no logging
  120.     loopcount = 1        ; set loop counter at zero
  121.  
  122.     ; look for profile.asp
  123.     fopen macroindex "profile.mac" "rb"
  124.     if success
  125.         macroflag = 1
  126.     endif
  127.     
  128.     while forever
  129.         call get_cmd
  130.         switch cmd1
  131.  
  132.         ; commands with 1 second pause
  133.         case "default"
  134.             tmpstr = "ds"
  135.             goto jump1here
  136.         case "autosetup"
  137.             tmpstr = "as"
  138.             call send2meter with tmpstr,&reterror,longtimeout
  139.             goto jump2here
  140.         case "reset"
  141.             tmpstr = "ri"
  142.     jump1here:
  143.             call send2meter with tmpstr,&reterror,normal
  144.     jump2here:
  145.             if reterror
  146.                 call write_user with "ERROR: reset not done"
  147.                 loopwhile
  148.             endif
  149.             pause 1
  150.         endcase
  151.  
  152.         ; file logging commands
  153.         case "logon"
  154.             fopen logindex cmd2 "wb"
  155.             if failure
  156.                 strfmt tmpstr "ERROR: cannot write %s" cmd2
  157.                 call write_user with tmpstr
  158.                 loopwhile
  159.             endif
  160.             logflag = 1
  161.         endcase
  162.         case "logoff"
  163.             fclose logindex
  164.             logflag = 0
  165.         endcase
  166.  
  167.         ; generic single line commands
  168.         case "local"
  169.             tmpstr = "gl"
  170.             goto jumphere
  171.         case "remote"
  172.             tmpstr = "gr"
  173.             goto jumphere
  174.         case "lockout"
  175.             tmpstr = "ll"
  176.             goto jumphere
  177.         case "trigger"
  178.             tmpstr = "ta"
  179.             goto jumphere
  180.         case "arm"
  181.             tmpstr = "at"
  182.             goto jumphere
  183.         case "recall"
  184.             strfmt tmpstr "rs %s" cmd2
  185.             goto jumphere
  186.         case "save"
  187.             strfmt tmpstr "ss %s" cmd2
  188.     jumphere:
  189.             call send2meter with tmpstr,&reterror,normal
  190.             if reterror
  191.                 call write_user with "ERROR: meter not ready"
  192.             endif
  193.         endcase
  194.  
  195.         case "loop"
  196.             looppos = macropos
  197.         endcase
  198.  
  199.         case ":"
  200.         endcase
  201.  
  202.         case "put"
  203.             ; open up the file
  204.             fopen readindex cmd2 "rb"
  205.             if failure
  206.                 strfmt tmpstr "ERROR: cannot open %s" cmd2
  207.                 call write_user with tmpstr
  208.                 loopwhile
  209.             endif
  210.  
  211.             ; the following is a modified version  of send2meter
  212.             rflush        ; clean up anything that has been 
  213.                     ; received
  214.             transmit "ps"
  215.  
  216.             ; send the data string
  217.             fgets readindex tmpstr
  218.             eof readindex tmplen
  219.  
  220.             while !tmplen
  221.                 transmit tmpstr
  222.                 fgets readindex tmpstr
  223.                 eof readindex tmplen
  224.             endwhile
  225.  
  226.             ; close up the file
  227.             fclose readindex
  228.  
  229.             ; send the terminator
  230.             computc cret
  231.  
  232.             ; get the acknowledge
  233.             comgetcd retack
  234.             if retack == -1        ; timeout!
  235.                 call write_user with "ERROR: meter not ready"
  236.                 loopwhile
  237.             endif
  238.             comgetcd terminator    ; pitch the terminator
  239.             if terminator != cret    ; sync up problem or timeout
  240.                 call write_user with "ERROR: meter not ready"
  241.                 loopwhile
  242.             endif
  243.             if retack != '0'        ; check the ack code
  244.                 call write_user with "ERROR: meter not ready"
  245.                 loopwhile
  246.             endif
  247.         endcase
  248.  
  249.         case "get"
  250.             call send2meter with "qs",&reterror,normal
  251.             if reterror
  252.                 call write_user with "ERROR: meter not ready"
  253.                 loopwhile
  254.             endif
  255.  
  256.             ; open up the file
  257.             fopen readindex cmd2 "wb"
  258.             if failure
  259.                 strfmt tmpstr "ERROR: cannot open %s" cmd2
  260.                 call write_user with tmpstr
  261.                 loopwhile
  262.             endif
  263.  
  264.             ; get the first string and see if additional ones 
  265.             call getmeter with &retstr,&reterror,normal
  266.             fputs readindex retstr
  267.  
  268.             ; look for the extended strings
  269.             while (reterror == 1)
  270.                 call getmeter with &retstr,&reterror,normal
  271.                 fputs readindex retstr
  272.             endwhile
  273.  
  274.             ; close up the file
  275.             fputs readindex "`r`n"
  276.             fclose readindex
  277.         endcase
  278.  
  279.         case "read"
  280.             strfmt tmpstr "qm %s,v" cmd2
  281.             call send2meter with tmpstr,&reterror,normal
  282.             if reterror
  283.                 call write_user with "ERROR: meter not ready"
  284.                 loopwhile
  285.             endif
  286.             call getmeter with &retstr,&reterror,normal
  287.             if (reterror)
  288.                 call write_user with "ERROR: can't get measurement"
  289.                 loopwhile
  290.             endif
  291.             call write_user with retstr
  292.  
  293.             ; store the readvalue in a nonvolatile place
  294.             atof retstr readvalue
  295.  
  296.             ; if optional filename is present
  297.             strlen cmd3 tmplen
  298.             if (tmplen)
  299.                 fopen readindex cmd3 "ab"
  300.                 if failure
  301.                     strfmt tmpstr "ERROR: cannot open %s" cmd3
  302.                     call write_user with tmpstr
  303.                     loopwhile
  304.                 endif
  305.                 strfmt tmpstr "%s,%s,%e`r`n" $date $time1 readvalue
  306.                 fputs readindex tmpstr
  307.                 if (failure)
  308.                     call write_user with "ERROR: cannot write disk"
  309.                 endif
  310.                 fclose readindex
  311.             endif
  312.         endcase
  313.             
  314.         ; macro related commands
  315.         case "beep"
  316.             sound 1000 50
  317.         endcase
  318.         case "dir"
  319.             strlen cmd2 tmplen
  320.             if (!tmplen)
  321.                 cmd2 = "*.*"
  322.             endif
  323.             dir cmd2
  324.         endcase
  325.         case "shell"
  326.             shell
  327.         endcase
  328.         case "del"
  329.             delete cmd2
  330.             if failure
  331.                 strfmt tmpstr "ERROR: can't delete %s" cmd2
  332.                 call write_user with tmpstr
  333.             endif
  334.         endcase
  335.         case "ren"
  336.             rename cmd2 cmd3
  337.             if failure
  338.                 strfmt tmpstr "ERROR: can't rename %s to %s" cmd2 cmd3
  339.                 call write_user with tmpstr
  340.             endif
  341.         endcase
  342.         case "cd"
  343.             getfattr cmd2 tmpstr
  344.             if failure
  345.                 strfmt tmpstr "ERROR: no directory %s" cmd2
  346.                 call write_user with tmpstr
  347.                 loopwhile
  348.             endif
  349.             find tmpstr "D"
  350.             if not found
  351.                 strfmt tmpstr "ERROR: no directory %s" cmd2
  352.                 call write_user with tmpstr
  353.                 loopwhile
  354.             endif
  355.             chdir cmd2
  356.         endcase
  357.         case "type"
  358.             type cmd2
  359.         endcase
  360.         case "edit"
  361.             strfmt tmpstr "edit %s" cmd2
  362.             run tmpstr
  363.         endcase
  364.         case "rmdir"
  365.             rmdir cmd2
  366.             if failure
  367.                 call write_user with "ERROR: can't remove directory"
  368.             endif
  369.         endcase
  370.         case "mkdir"
  371.             mkdir cmd2
  372.             if failure
  373.                 call write_user with "ERROR: can't create directory"
  374.             endif
  375.         endcase
  376.         case "pwd"
  377.             getdir 0 tmpstr
  378.             call write_user with tmpstr
  379.         endcase
  380.         case "?"
  381.             type "flukecom.hlp"
  382.         endcase
  383.         case "play"
  384.             loopcount = 1
  385.             looppos = 0
  386.             strlen cmd2 tmplen
  387.             if (tmplen == 0)
  388.                 call write_user with "ERROR: no macro file"
  389.                 loopwhile
  390.             endif
  391.             fopen macroindex cmd2 "rb"
  392.             if failure
  393.                 strfmt tmpstr "ERROR: no macro file %s" cmd2
  394.                 call write_user with tmpstr
  395.                 loopwhile
  396.             endif
  397.             macroflag = 1
  398.         endcase
  399.         case "zero"
  400.             loopcount = 1
  401.         endcase
  402.         case "ifgoto"
  403.             atof cmd2 mingoto
  404.             atof cmd3 maxgoto
  405.             atol cmd4 tmplong
  406.             
  407.             ; check to see if inside limits
  408.             if (readvalue >= mingoto) && (readvalue <= maxgoto) && (macroflag) && ((loopcount < tmplong) || (tmplong <= 0))
  409.                 if (tmplong >= 0)
  410.                     loopcount++
  411.                 endif
  412.                 fseek macroindex looppos 0
  413.             endif
  414.         endcase
  415.         case "ifnotgoto"
  416.             atof cmd2 mingoto
  417.             atof cmd3 maxgoto
  418.             atol cmd4 tmplong
  419.             
  420.             ; check to see if inside limits
  421.             if ((readvalue < mingoto) || (readvalue > maxgoto)) && (macroflag) && ((loopcount < tmplong) || (tmplong <= 0))
  422.                 if (tmplong >= 0)
  423.                     loopcount++
  424.                 endif
  425.                 fseek macroindex looppos 0
  426.             endif
  427.         endcase
  428.         case "timestamp"
  429.             strfmt tmpstr "%s %s" $date $time1
  430.             call write_user with tmpstr
  431.  
  432.             ; if optional filename is present
  433.             strlen cmd2 tmplen
  434.             if (tmplen)
  435.                 fopen readindex cmd2 "ab"
  436.                 if failure
  437.                     strfmt tmpstr "ERROR: cannot open %s" cmd3
  438.                     call write_user with tmpstr
  439.                     loopwhile
  440.                 endif
  441.                 strfmt tmpstr "%s,%s`r`n" $date $time1 readvalue
  442.                 fputs readindex tmpstr
  443.                 if (failure)
  444.                     call write_user with "ERROR: cannot write disk"
  445.                 endif
  446.                 fclose readindex
  447.             endif
  448.         endcase
  449.         case "pause"
  450.             strlen cmd2 tmplen
  451.             if (tmplen == 0)
  452.                 call write_user with "ERROR: no delay"
  453.                 loopwhile
  454.             endif
  455.             atoi cmd2 tmplen
  456.             if (tmplen == 0)
  457.                 call write_user with "ERROR: illegal delay"
  458.                 loopwhile
  459.             endif
  460.             pause tmplen
  461.             if failure
  462.                 call write_user with "WARNING: aborted"
  463.             endif
  464.         endcase
  465.         case "clock+"
  466.             atoi cmd2 tmplen    ; get the user hour
  467.             time tmpstr 1        ; get the current time
  468.             atoi tmpstr hourwait    ; find the hour
  469.             hourwait = hourwait + tmplen
  470.             atoi cmd3 tmplen    ; get the user minute
  471.             substr retstr tmpstr 3 2
  472.             atoi retstr minwait
  473.             minwait = minwait + tmplen
  474.  
  475.             ; check for clock rollover
  476.             if (minwait >= 60)
  477.                 minwait = 0
  478.                 hourwait++
  479.             endif
  480.             if (hourwait >= 24)
  481.                 hourwait = 0
  482.             endif
  483.             suspend until hourwait minwait
  484.             if failure
  485.                 call write_user with "WARNING: aborted"
  486.             endif
  487.         endcase
  488.         case "clock"
  489.             call check_range with cmd2, 0, 23, &hourwait, &reterror
  490.             if reterror
  491.                 call write_user with "ERROR: illegal delay"
  492.                 loopwhile
  493.             endif
  494.             call check_range with cmd3, 0, 59, &minwait, &reterror
  495.             if reterror
  496.                 call write_user with "ERROR: illegal delay"
  497.                 loopwhile
  498.             endif
  499.             suspend until hourwait minwait
  500.             if failure
  501.                 call write_user with "WARNING: aborted"
  502.             endif
  503.         endcase
  504.         case "init"
  505.             if (logflag)
  506.                 fclose logindex
  507.                 logflag = 0
  508.             endif
  509.             execute "flukeint"
  510.         endcase
  511.         case "quit"
  512.             exitwhile
  513.         endcase
  514.  
  515.         case "version"
  516.             call write_user with versionstr
  517.             call send2meter with "id",&reterror,normal
  518.             if reterror
  519.                 call write_user with "ERROR: meter not ready"
  520.                 loopwhile
  521.             endif
  522.             call getmeter with &retstr,&reterror,normal
  523.             if (reterror)
  524.                 call write_user with "ERROR: can't get id from meter"
  525.                 loopwhile
  526.             endif
  527.             call write_user with retstr
  528.         endcase
  529.  
  530.         case "copy"
  531.             call copy_cmd
  532.         endcase
  533.  
  534.         case ""
  535.         endcase
  536.  
  537.         default
  538.             strfmt tmpstr "ERROR: command %s" cmd1
  539.             call write_user with tmpstr
  540.         endcase
  541.         endswitch
  542.     endwhile
  543.     execute "flukexit"
  544. endproc
  545.  
  546. ; for copy command from above, all parameters are handled with globals
  547. ; yeah, I know, live with it...
  548.  
  549. proc copy_cmd
  550.     integer wavenum, dwavenum
  551.     integer reterror
  552.  
  553.     ; for file naming
  554.     string basename, dbasename
  555.     string tmpstr
  556.  
  557.     ; look at the command string and figure out what to do
  558.     call wave_number with cmd2,&wavenum
  559.     call wave_number with cmd3,&dwavenum
  560.  
  561.     ; check for existence of command strings
  562.     strlen cmd2 reterror
  563.     if (!reterror)
  564.         call write_user with "ERROR: no source"
  565.         return
  566.     endif
  567.  
  568.     ; assume that this is a basename
  569.     basename = cmd2
  570.  
  571.     strlen cmd3 reterror
  572.     if (!reterror)
  573.         call write_user with "ERROR: no destination"
  574.         return
  575.     endif
  576.  
  577.     ; check for special case of datestamp
  578.  
  579.     strcmp cmd3 "datestamp"
  580.     if success
  581.         call make_date with &dbasename
  582.     else
  583.         dbasename = cmd3
  584.     endif
  585.  
  586.     ; please note that the basename and dbasename variables
  587.     ; are always set to the cmd2 and cmd3 respectively, regardless
  588.     ; of the actual operation.  For example, even if a keyword is
  589.     ; found as a source or destination, the cmd2 or cmd3 will
  590.     ; be used to set the value of basename/dbasename.  The only
  591.     ; exception to this is in the case of datestamp.  The wavenum
  592.     ; and dwavenum vars should be used to key the operation.  This
  593.     ; is a bit of a hack but most of this is.
  594.  
  595.     ; copy from meter to specified file
  596.     if (wavenum) && (!dwavenum)
  597.         call get_waveform with wavenum,&reterror
  598.         if (reterror)
  599.             call write_user with "ERROR: can't get meter data"
  600.             return
  601.         endif
  602.         call write_waveform with dbasename,&reterror
  603.         if (reterror)
  604.             call write_user with "ERROR: can't write to disk"
  605.             return
  606.         endif
  607.     endif
  608.  
  609.     ; copy from specified file to meter
  610.     if (!wavenum) && (dwavenum)
  611.         call read_waveform with basename,&reterror
  612.         if (reterror)
  613.             strfmt tmpstr "ERROR: can't read disk file %s" basename
  614.             call write_user with tmpstr
  615.             return
  616.         endif
  617.         call send_waveform with dwavenum,&reterror
  618.         if (reterror)
  619.             call write_user with "ERROR: can't write to meter"
  620.             return
  621.         endif
  622.     endif
  623.  
  624.     ; copy from meter to meter
  625.     if (wavenum) && (dwavenum)
  626.         call get_waveform with wavenum,&reterror
  627.         if (reterror)
  628.             call write_user with "ERROR: can't get meter data"
  629.             return
  630.         endif
  631.         call send_waveform with dwavenum,&reterror
  632.         if (reterror)
  633.             call write_user with "ERROR: can't write to meter"
  634.             return
  635.         endif
  636.     endif
  637.  
  638.     ; copy from file to file
  639.     if (!wavenum) && (!dwavenum)
  640.         call read_waveform with basename,&reterror
  641.         if (reterror)
  642.             strfmt tmpstr "ERROR: can't read disk file %s" basename
  643.             call write_user with tmpstr
  644.             return
  645.         endif
  646.         call write_waveform with dbasename,&reterror
  647.         if (reterror)
  648.             call write_user with "ERROR: can't write to disk"
  649.             return
  650.         endif
  651.     endif
  652. endproc
  653.  
  654. ; reads data from disk and pulls it into bigresp
  655. ; returns zero if ok, 2 if error
  656.  
  657. proc read_waveform
  658.     strparm basename    ; source basename
  659.     intparm restatus
  660.  
  661.     string tmpstr
  662.     integer reterror    ; std error return
  663.     
  664.     tmpstr = basename
  665.     strcat tmpstr ".dat"    ; get the binary data
  666.     fopen srcindex tmpstr "rb"
  667.     if failure
  668.         restatus = 2
  669.         return
  670.     endif
  671.     fread srcindex bigresp1 maxstrlen reterror
  672.     fread srcindex bigresp2 maxstrlen reterror
  673.     fread srcindex bigresp3 maxstrlen reterror
  674.     fread srcindex bigresp4 maxstrlen reterror
  675.     fread srcindex bigresp5 maxstrlen reterror
  676.     fread srcindex bigresp6 maxstrlen reterror
  677.     fread srcindex bigresp7 shortstrlen reterror
  678.     if (reterror != shortstrlen)
  679.         restatus = 2
  680.         return
  681.     endif
  682.  
  683.     ; get the header data
  684.     tmpstr = basename
  685.     strcat tmpstr ".hdr"    ; get the binary data
  686.     fopen srcindex tmpstr "rb"
  687.     if failure
  688.         restatus = 2
  689.         return
  690.     endif
  691.     fgets srcindex id
  692.     fgets srcindex xunit
  693.     fgets srcindex yunit
  694.     fgets srcindex tmpstr
  695.     atof tmpstr xzero
  696.     fgets srcindex tmpstr
  697.     atof tmpstr yzero
  698.     fgets srcindex tmpstr
  699.     atof tmpstr xdelta
  700.     fgets srcindex tmpstr
  701.     atof tmpstr ydelta
  702.     fgets srcindex tmpstr
  703.     atoi tmpstr xsample
  704.     fgets srcindex tmpstr
  705.     atoi tmpstr ylevel
  706.     fclose srcindex
  707.     restatus = 0
  708. endproc
  709.  
  710. ; takes data from bigresp variables and writes disk files
  711. ; returns zero if ok, 2 if error
  712.  
  713. proc write_waveform
  714.     strparm dbasename    ; destination basename
  715.     intparm restatus    ; return status
  716.  
  717.     string tmpstr
  718. comment
  719. ; this stuff is commented out because the csv file is created by an
  720. ; external c file
  721.     integer counter        ; pointer into arrays
  722.     integer reterror    ; return status from routines
  723.  
  724.     ; for calculations
  725.     float realx,realy
  726. endcomment
  727.  
  728.     ; make up the binary file
  729.     tmpstr = dbasename
  730.     strcat tmpstr ".dat"
  731.     fopen destindex tmpstr "wb"
  732.     if failure
  733.         restatus = 2
  734.         return
  735.     endif
  736.  
  737.     ; write all this binary stuff out
  738.     fwrite destindex bigresp1 maxstrlen
  739.     fwrite destindex bigresp2 maxstrlen
  740.     fwrite destindex bigresp3 maxstrlen
  741.     fwrite destindex bigresp4 maxstrlen
  742.     fwrite destindex bigresp5 maxstrlen
  743.     fwrite destindex bigresp6 maxstrlen
  744.     fwrite destindex bigresp7 shortstrlen
  745.     if failure
  746.         call write_user with "ERROR: cannot write disk"
  747.     endif
  748.     fclose destindex
  749.  
  750.     ; make up the hdr file
  751.     tmpstr = dbasename
  752.     strcat tmpstr ".hdr"
  753.     fopen destindex tmpstr "wb"
  754.     if failure
  755.         restatus = 2
  756.         return
  757.     endif
  758.     fstrfmt destindex "%s`r`n" id
  759.     fstrfmt destindex "%s`r`n" xunit
  760.     fstrfmt destindex "%s`r`n" yunit
  761.     fstrfmt destindex "%e Xzero`r`n" xzero
  762.     fstrfmt destindex "%e Yzero`r`n" yzero
  763.     fstrfmt destindex "%e Xdelta`r`n" xdelta
  764.     fstrfmt destindex "%e Ydelta`r`n" ydelta
  765.     fstrfmt destindex "%d Xsample`r`n" xsample
  766.     fstrfmt destindex "%d Ylevel`r`n" ylevel
  767.     if failure
  768.         call write_user with "ERROR: cannot write to disk"
  769.     endif
  770.     fclose destindex
  771.  
  772. comment
  773. ; all of this stuff is commented out since this runs way to slow
  774.     ; make up the csv file
  775.     tmpstr = dbasename
  776.     strcat tmpstr ".csv"
  777.     fopen destindex tmpstr "wb"
  778.     if failure
  779.         restatus = 2
  780.         return
  781.     endif
  782.  
  783.     ; create the csv strings
  784.     fstrfmt destindex "%s`r`n" dbasename
  785.     fstrfmt destindex "%s,%s`r`n" xunit yunit
  786.  
  787.     ; initialize the array fetching
  788.     call zero_array
  789.     counter = 0
  790.     call get_array with &reterror
  791.     while (reterror != -1)
  792.         realx = (counter * xdelta) + xzero
  793.         realy = ((reterror - 128) * ydelta) - yzero
  794.         fstrfmt destindex "%e,%e`r`n" realx realy
  795.         counter++
  796.         call get_array with &reterror
  797.     endwhile
  798.     fclose destindex
  799. endcomment
  800.     strfmt tmpstr "makecsv %s" dbasename
  801.     run tmpstr NOCLEAR
  802.     restatus = 0
  803. endproc
  804.  
  805. ; get data from bigresp variables and sends to meter
  806. ; returns zero if ok, 2 if error
  807.  
  808. proc send_waveform
  809.     intparm dwavenum
  810.     intparm restatus
  811.  
  812.     string tmpstr
  813.     integer reterror
  814.  
  815.     strfmt tmpstr "pw%d" dwavenum
  816.     call send2meter with tmpstr,&reterror,extended
  817.     if (reterror)
  818.         restatus = 2
  819.         return
  820.     endif
  821.     restatus = 0
  822. endproc
  823.  
  824. ; gets data from meter and puts into the bigresp variables
  825. ; returns zero if ok, 2 if error
  826.  
  827. proc get_waveform
  828.     intparm wavenum        ; keycode for waveform
  829.     intparm restatus    ; return code from operation
  830.  
  831.     integer counter        ; for parsing
  832.     string tmpstr
  833.     string retstr        ; return string from get operation
  834.     integer reterror    ; return from send2meter
  835.  
  836.     strfmt tmpstr "qw%d" wavenum
  837.     call send2meter with tmpstr,&reterror,normal
  838.     if (reterror)
  839.         restatus = 2
  840.         return
  841.     endif
  842.     call getmeter with &retstr,&reterror,extended
  843.     if (reterror)
  844.         restatus = 2
  845.         return
  846.     endif
  847.  
  848.     ; get the values from the response string
  849.     counter = 0
  850.     call parse_str with retstr,&id,&counter,commachar
  851.     call parse_str with retstr,&yunit,&counter,commachar
  852.     call parse_str with retstr,&xunit,&counter,commachar
  853.     call parse_str with retstr,&tmpstr,&counter,commachar
  854.     atof tmpstr yzero
  855.     call parse_str with retstr,&tmpstr,&counter,commachar
  856.     atof tmpstr xzero
  857.     call parse_str with retstr,&tmpstr,&counter,commachar
  858.     atof tmpstr ydelta
  859.     call parse_str with retstr,&tmpstr,&counter,commachar
  860.     atof tmpstr xdelta
  861.     call parse_str with retstr,&tmpstr,&counter,commachar
  862.     atoi tmpstr ylevel
  863.     call parse_str with retstr,&tmpstr,&counter,commachar
  864.     atoi tmpstr xsample
  865.     restatus = 0
  866. endproc
  867.  
  868. ; zero pointers into array
  869.  
  870. proc zero_array
  871.     bigpointer = 0
  872.     bigstring = 1
  873. endproc
  874.  
  875. ; gets value from array
  876.  
  877. proc get_array
  878.     intparm reterror
  879.  
  880.     integer    biglength        ; length of current string
  881.  
  882.     switch bigstring
  883.     case 1
  884.         strpeek bigresp1 bigpointer reterror
  885.         biglength = maxstrlen
  886.     endcase
  887.     case 2
  888.         strpeek bigresp2 bigpointer reterror
  889.         biglength = maxstrlen
  890.     endcase
  891.     case 3
  892.         strpeek bigresp3 bigpointer reterror
  893.         biglength = maxstrlen
  894.     endcase
  895.     case 4
  896.         strpeek bigresp4 bigpointer reterror
  897.         biglength = maxstrlen
  898.     endcase
  899.     case 5
  900.         strpeek bigresp5 bigpointer reterror
  901.         biglength = maxstrlen
  902.     endcase
  903.     case 6
  904.         strpeek bigresp6 bigpointer reterror
  905.         biglength = maxstrlen
  906.     endcase
  907.     case 7
  908.         strpeek bigresp7 bigpointer reterror
  909.         biglength = shortstrlen
  910.     endcase
  911.     default
  912.         reterror = -1
  913.         return
  914.     endcase
  915.     endswitch
  916.  
  917.     ; point to next item in array
  918.     bigpointer++
  919.  
  920.     ; clean up if necessary
  921.     if (bigpointer >= biglength)
  922.         bigpointer = 0
  923.         bigstring++ 
  924.     endif
  925. endproc
  926.  
  927. ; checks correct range of numeric value
  928. ; minval is lowest ok value 
  929. ; maxval is highest ok value
  930. ; returns value in integer,
  931. ; 0 error return indicates, ok, 2 indicates error
  932.  
  933. proc check_range
  934.     strparm instr
  935.     intparm minval, maxval
  936.     intparm value
  937.     intparm reterror
  938.  
  939.     integer strlength
  940.  
  941.     ; check for zero length string
  942.     strlen instr strlength
  943.     if (!strlength)
  944.         reterror = 2
  945.         return
  946.     endif
  947.  
  948.     ; convert the string
  949.     atoi instr value
  950.     if (value >= minval) && (value <= maxval)
  951.         reterror = 0
  952.         return
  953.     endif
  954.     reterror = 2
  955. endproc
  956.  
  957. ; create a string with date code
  958.  
  959. proc make_date
  960.     strparm outstr
  961.  
  962.     string tmpstr
  963.     string datestr
  964.     string timestr
  965.  
  966.     outstr = ""
  967.     date datestr                ; get appropo strings
  968.     time timestr 1    
  969.     substr tmpstr datestr 3 2        ; get the day
  970.     strcat outstr tmpstr
  971.     substr tmpstr timestr 0 2        ; get the hour
  972.     strcat outstr tmpstr
  973.     substr tmpstr timestr 3 2        ; get the minute
  974.     strcat outstr tmpstr
  975.     substr tmpstr timestr 6 2        ; get the second
  976.     strcat outstr tmpstr
  977. endproc
  978.  
  979. proc write_user
  980.     strparm outstr
  981.  
  982.     string tmpstr
  983.  
  984.     strfmt tmpstr "%s`r`n" outstr
  985.     message tmpstr
  986.     if (logflag)
  987.         fputs logindex tmpstr 
  988.         if failure
  989.             message "ERROR: cannot write to disk`r`n"
  990.         endif
  991.     endif
  992. endproc
  993.  
  994. proc nocr_write_user
  995.     strparm outstr
  996.  
  997.     message outstr
  998.     if (logflag)
  999.         fputs logindex outstr 
  1000.         if failure
  1001.             message "ERROR: cannot write to disk`r`n"
  1002.         endif
  1003.     endif
  1004. endproc
  1005.  
  1006. ; this routine is a general token parser which is intended to
  1007. ; look for the parsechar and return the current token from the
  1008. ; current location in the string up but not including the separator
  1009. ; It will return the token found into the string which is passed,
  1010. ; a null string is returned if no token is found or if end of the string
  1011. ; The variable pointer is used to offset from the beginning of the string
  1012. ; where to start the search and it is left at pointer at the first character
  1013. ; beyound the end of the string (string length)
  1014. ; or the first whitespace following the current token
  1015. ; Strings are based at 0 start
  1016. ; parsechar is used to determine the character to parse on
  1017.  
  1018. proc parse_str
  1019.     strparm    instr
  1020.     strparm outstr
  1021.     intparm pointer
  1022.     intparm parsechar
  1023.  
  1024.     integer lastchar
  1025.     integer currchar
  1026.     string currcharstr
  1027.  
  1028.     outstr = ""
  1029.  
  1030.     ; get the length of the string
  1031.     strlen instr lastchar
  1032.     if (!lastchar)
  1033.         return
  1034.     endif
  1035.  
  1036.     ; check if pointer is beyond end of string
  1037.     if (pointer >= lastchar)
  1038.         return
  1039.     endif
  1040.         
  1041.     strpeek instr pointer currchar
  1042.  
  1043.     ; strip off leading whitespace
  1044.     while (currchar == parsechar)
  1045.         pointer++
  1046.         if (pointer == lastchar)
  1047.             return
  1048.         endif
  1049.         strpeek instr pointer currchar
  1050.     endwhile
  1051.  
  1052.     ; find the next whitespace, this is token
  1053.     while (currchar != parsechar)
  1054.         key2ascii currchar currcharstr
  1055.         strcat outstr currcharstr
  1056.         pointer++
  1057.         if (pointer == lastchar)
  1058.             return
  1059.         endif
  1060.         strpeek instr pointer currchar
  1061.     endwhile
  1062. endproc
  1063.  
  1064. ; return error code
  1065. ; of 1 indicates an ack error existed on the receive
  1066. ; this is a warning that the ack code is incorrect
  1067. ; of 2 indicates a sync problem existed on the receive (or timeout)
  1068. ; this is a fatal
  1069. ; Response string must be handled separately.
  1070.  
  1071. proc send2meter
  1072.     strparm instr
  1073.     intparm reterror
  1074.     intparm    opcode
  1075.  
  1076.     string tmpstr
  1077.     integer retack            ; acknowledge byte
  1078.     integer terminator
  1079.     integer checksum
  1080.     integer counter            ; for long timeout tries
  1081.  
  1082.     rflush                ; clean up anything that has been 
  1083.                     ; received
  1084.     strfmt tmpstr "%s`r" instr    ; format up the data to send
  1085.     transmit tmpstr
  1086.  
  1087.     counter = 0
  1088.     comgetcd retack
  1089.     if (opcode == longtimeout) && (counter < longtimetries) && (retack == -1)
  1090.         comgetcd retack
  1091.         counter++
  1092.     endif
  1093.     if retack == -1            ; timeout!
  1094.         reterror = 2
  1095.         return
  1096.     endif
  1097.     comgetcd terminator        ; pitch the terminator
  1098.     if terminator != cret        ; sync up problem or timeout
  1099.         reterror = 2
  1100.         return
  1101.     endif
  1102.     if retack != '0'        ; check the ack code
  1103.         reterror = 1
  1104.         return
  1105.     endif
  1106.     ; is this an extended waveform operation
  1107.     if (opcode == extended)
  1108.         checksum = 0
  1109.         call zero_array
  1110.         call get_array with &retack
  1111.         while (retack != -1)
  1112.             checksum = checksum + retack
  1113.             computc retack
  1114.             call get_array with &retack
  1115.         endwhile
  1116.         checksum = checksum & 255
  1117.         computc checksum
  1118.  
  1119.         ; wait for the acknowledge byte
  1120.         comgetcd retack
  1121.         if retack == -1            ; timeout!
  1122.             reterror = 2
  1123.             return
  1124.         endif
  1125.         comgetcd terminator        ; pitch the terminator
  1126.         if terminator != cret        ; sync up problem or timeout
  1127.             reterror = 2
  1128.             return
  1129.         endif
  1130.         if retack != '0'        ; check the ack code
  1131.             reterror = 2
  1132.             return
  1133.         endif
  1134.     endif
  1135.     reterror = 0
  1136. endproc
  1137.  
  1138. ; this routine checks the input string and reduces it to the correct
  1139. ; waveform number
  1140. ; It requires the string to be sent with the ascii descripter and it
  1141. ; returns a value for the waveform number, 0 if not recognized.
  1142.  
  1143. proc wave_number
  1144.     strparm instr
  1145.     intparm reterror
  1146.  
  1147.     switch instr
  1148.     case "a"
  1149.         reterror = 101
  1150.     endcase
  1151.     case "b"
  1152.         reterror = 102
  1153.     endcase
  1154.     case "ab"
  1155.         reterror = 103
  1156.     endcase
  1157.     case "temp1"
  1158.         reterror = 104
  1159.     endcase
  1160.     case "temp2"
  1161.         reterror = 105
  1162.     endcase
  1163.     case "temp3"
  1164.         reterror = 106
  1165.     endcase
  1166.     case "memory4"
  1167.         reterror = 107
  1168.     endcase
  1169.     case "memory5"
  1170.         reterror = 108
  1171.     endcase
  1172.     case "memory6"
  1173.         reterror = 109
  1174.     endcase
  1175.     case "memory7"
  1176.         reterror = 110
  1177.     endcase
  1178.     case "memory8"
  1179.         reterror = 111
  1180.     endcase
  1181.     default
  1182.         reterror = 0
  1183.     endcase
  1184.     endswitch
  1185. endproc
  1186.  
  1187. ; get the next command
  1188.  
  1189. proc get_cmd
  1190.     string tmpstr            ; response string from get
  1191.     integer counter            ; position in string
  1192.  
  1193.     call nocr_write_user with "flukecom> "
  1194.  
  1195.     ; see if an esc or abort key was hit during operation
  1196.     if (hitkey)
  1197.         kflush
  1198.         if (macroflag)
  1199.             macroflag = 0
  1200.             fclose macroindex
  1201.         endif
  1202.     endif
  1203.     if (macroflag)
  1204.  
  1205.         ; get input from macro file
  1206.         fgets macroindex tmpstr
  1207.         ftell macroindex macropos    ; get pointer where to
  1208.                         ; starting from
  1209.         if success
  1210.  
  1211.             ; check for eof
  1212.             if eof macroindex
  1213.                 fclose macroindex
  1214.                 macroflag = 0
  1215.                 get tmpstr
  1216.                 ; aborted out with esc key
  1217.                 if (failure)
  1218.                     tmpstr = ""
  1219.                 endif
  1220.                 if (logflag)
  1221.                     fputs logindex tmpstr
  1222.                     if failure
  1223.                         call write_user with "ERROR: cannot write to disk"
  1224.                     endif
  1225.                 endif
  1226.                 call write_user with ""
  1227.             else
  1228.                 ; got the string ok
  1229.                 call write_user with tmpstr
  1230.             endif
  1231.         else
  1232.             ; end of file, clean up
  1233.             ; need some error indication here
  1234.             fclose macroindex
  1235.             macroflag = 0
  1236.             get tmpstr
  1237.             ; aborted out with esc key
  1238.             if (failure)
  1239.                 tmpstr = ""
  1240.             endif
  1241.             if (logflag)
  1242.                 fputs logindex tmpstr
  1243.                 if failure
  1244.                     call write_user with "ERROR: cannot write to disk"
  1245.                 endif
  1246.             endif
  1247.             call write_user with ""
  1248.         endif
  1249.     else
  1250.         ; normal user input
  1251.         get tmpstr
  1252.         ; aborted out with esc key
  1253.         if (failure)
  1254.             tmpstr = ""
  1255.         endif
  1256.         if (logflag)
  1257.             fputs logindex tmpstr
  1258.             if failure
  1259.                 call write_user with "ERROR: cannot write to disk"
  1260.             endif
  1261.         endif
  1262.         call write_user with ""
  1263.     endif
  1264.     strlwr tmpstr            ; convert to lower case
  1265.     counter = 0
  1266.     call parse_str with tmpstr,&cmd1,&counter,spacechar
  1267.     call parse_str with tmpstr,&cmd2,&counter,spacechar
  1268.     call parse_str with tmpstr,&cmd3,&counter,spacechar
  1269.     call parse_str with tmpstr,&cmd4,&counter,spacechar
  1270. endproc
  1271.  
  1272. ; this routine is an internally called routine from above
  1273. ; that is used to basically minimize the amount of recalled code
  1274. ;
  1275. ; It requires the user pass a string to concatenate onto
  1276. ; a pointer for the checksum integer
  1277. ; a value for the maximum number of characters to fetch
  1278. ; a pointer to an error return which will be 0 if success or 2 if not
  1279. ; Please note that the error return is checked, if an error value is
  1280. ; passed in, then the routine will abort
  1281. ; 
  1282.  
  1283. proc suck_em_up
  1284.     strparm outstr
  1285.     intparm checksum
  1286.     intparm maxget
  1287.     intparm reterror
  1288.  
  1289.     integer pointcount
  1290.     string tmpstr
  1291.     integer newchar
  1292.  
  1293.     ; check the error return
  1294.     if (reterror)
  1295.         return
  1296.     endif
  1297.  
  1298.     ; initialize the string and counter
  1299.     outstr = ""
  1300.     pointcount = 1
  1301.  
  1302.     ; get the first character
  1303.     comgetcd newchar
  1304.  
  1305.     while (newchar != -1)
  1306.         key2ascii newchar tmpstr    ; convert char to string
  1307.         strcat outstr tmpstr
  1308.         checksum = checksum + newchar
  1309.         pointcount++
  1310.         if (pointcount > maxget)
  1311.             reterror = 0
  1312.             return
  1313.         endif
  1314.         comgetcd newchar
  1315.     endwhile
  1316.  
  1317.     ; timeout condition
  1318.     reterror = 2
  1319. endproc
  1320.  
  1321. ; this routine gets the response string from the meter
  1322. ; If the response was succesful, then a string is returned and
  1323. ; of 0 indicates successful
  1324. ; of 1 indicates a continuation packet is pending
  1325. ; of 2 indicates a failure
  1326. ; NOTE THIS ROUTINE IS LIMITED TO 80 characters per string
  1327. ;
  1328. ; input parameter longgrab is normally set to zero for cret acquisition
  1329. ; If set to extended, then the routine will look for 8 commas, switch to the
  1330. ; getmeter_long routine to grab the samples, and verify the checksum
  1331.  
  1332. proc getmeter
  1333.     strparm outstr            ; string to return
  1334.     intparm reterror        ; error code to return
  1335.     intparm longgrab        ; operation code per above
  1336.  
  1337.     integer newchar            ; the latest character acquired
  1338.     string newcharstr        ; string version of the above
  1339.     integer    counter            ; length of the string to check for 
  1340.                     ; overflow of string
  1341.     integer commacount        ; number of commas in current string
  1342.                     ; used if longgrab = 1
  1343.  
  1344.     outstr = ""
  1345.     commacount = 0
  1346.     counter = 0
  1347.     comgetcd newchar
  1348.     while (newchar != -1) && (newchar != cret) && (commacount < maxcomma)
  1349.         key2ascii newchar newcharstr
  1350.         strcat outstr newcharstr
  1351.         counter++
  1352.  
  1353.         ; test to see if this is a implicit continuation string
  1354.         ; should never happen except when getting meter configuration
  1355.         if (counter >= maxstrlen)
  1356.             reterror = 1
  1357.             return
  1358.         endif
  1359.         if (newchar == ',') && (longgrab == extended)
  1360.             commacount++
  1361.         endif
  1362.         if (commacount != maxcomma)
  1363.             comgetcd newchar
  1364.         endif
  1365.     endwhile
  1366.     if (newchar == cret) && (longgrab == normal)
  1367.         reterror = 0
  1368.         return
  1369.     endif
  1370.     if (newchar == ',') && (longgrab == extended)
  1371.         ; call the long response handler
  1372.         call getmeter_long with &reterror
  1373.         return
  1374.     endif
  1375.     reterror = 2
  1376. endproc
  1377.  
  1378. ; this routine gets the waveform response
  1379. ; If the response was succesful, then a string is placed in the globals and
  1380. ; of 0 indicates successful
  1381. ; of 2 indicates a failure
  1382. ; NOTE THIS ROUTINE IS LIMITED TO 80 characters per string
  1383.  
  1384. proc getmeter_long
  1385.     intparm reterror        ; return error code
  1386.  
  1387.     integer newchar            ; current character being worked on
  1388.     integer checksum        ; calculated checksum
  1389.  
  1390.     ; initialize the checksum
  1391.     checksum = 0
  1392.     call suck_em_up with &bigresp1,&checksum,maxstrlen,&reterror
  1393.     call suck_em_up with &bigresp2,&checksum,maxstrlen,&reterror
  1394.     call suck_em_up with &bigresp3,&checksum,maxstrlen,&reterror
  1395.     call suck_em_up with &bigresp4,&checksum,maxstrlen,&reterror
  1396.     call suck_em_up with &bigresp5,&checksum,maxstrlen,&reterror
  1397.     call suck_em_up with &bigresp6,&checksum,maxstrlen,&reterror
  1398.     call suck_em_up with &bigresp7,&checksum,shortstrlen,&reterror
  1399.  
  1400.     if (reterror)
  1401.         return
  1402.     endif
  1403.  
  1404.     ; mask the checksum
  1405.     checksum = checksum & 255        
  1406.  
  1407.     ; check checksum
  1408.     comgetcd newchar
  1409.     if (newchar != checksum)
  1410.         reterror = 2
  1411.         return
  1412.     endif
  1413.  
  1414.     ; all ok
  1415.     reterror = 0
  1416. endproc
  1417.