pro read_pkt_file_404, $
    pfile=pfile, pkt_info=pkt_info, $
    pkt_struct=pkt_struct, pkt_data=pkt_data, $
    verbose=verbose, no_pctr=no_pctr, $
    frac=frac,daytime=daytime

expected_apid = pkt_info.expected_apid
apid_name = pkt_info.apid_name
pkt_size = pkt_info.pkt_size    ; bytes.
hdr_size = pkt_info.hdr_size    ; bytes.

data_size = pkt_size - hdr_size ; bytes.

openu, lun, pfile, /get_lun

; get size of file, and determine number of packet contained within.
fs = fstat( lun)
file_size = fs.size
npkts = floor( file_size/pkt_size)

if keyword_set( verbose) then $
    message, /info, string( file_size, npkts, format='("file size:",I9,",",X,"npkts:",I9,".")')

; here we use POINT_LUN and the PKT_SIZE variable to move to the N-th packet in the file,
; and read M packets, starting with that N-th packet.
; NOT YET IMPLEMENTED.

pkt_buff = assoc( lun, bytarr( pkt_size))

ul64_256 = ulong64( 256)

; elapsed seconds between 1 Jan 1900 and 1 Jan 1970;
; does not include UTC leap seconds.
dt_epoch = ulong64( 3600L*24L)*ulong64(julday( 1, 1, 1970, 0, 0, 0) - julday( 1, 1, 1900, 0, 0, 0)) ; s.

; elapsed seconds between first sample of packet and assigned header time stamp.
dt_packet = 0.d

pkt_struct = { clock:ulon64arr( npkts), $
    subsec:ulonarr( npkts), $
    t_hdr:dblarr( npkts), $
    selection:bytarr( npkts), $
    speed:bytarr( npkts), $
    samp_rate:uintarr( npkts), $
    n_sel_chan:intarr( npkts), $
    apid:ulonarr( npkts), $
    pseq_ctrl:bytarr( npkts), $
    apid_ctr:bytarr( npkts), $
    pkt_num:ulonarr( npkts) $
}

pkt_data = { $
    idpu_rstctr:bytarr( npkts), $
    ienables:uintarr( npkts), $
    idpu_version:bytarr( npkts), $
    idpu_mode:bytarr( npkts), $
    idpu_fgnd:bytarr( npkts), $
    idpu_errcode:bytarr( npkts), $
    idpu_errdata:uintarr( npkts), $
    idpu_errctr:bytarr( npkts), $
    idpu_cmdreg:uintarr( npkts), $
    idpu_cmdexp:bytarr( npkts), $
    idpu_cmdtot:bytarr( npkts), $
    idpu_loadadr:uintarr( npkts), $
    idpu_dumpadr:uintarr( npkts), $
    imemdump:bytarr( npkts, 16), $
    io_fpga:bytarr( npkts), $
    io_vc2cnt:bytarr( npkts), $
    io_vc3cnt:bytarr( npkts), $
    io_dcbctl:bytarr( npkts), $
    io_auxstat:bytarr( npkts), $
    io_uartstat:bytarr( npkts), $
    itm_enable:bytarr( npkts), $
    itm_errors:bytarr( npkts), $
    imon_p10va:bytarr( npkts), $
    imon_n10va:bytarr( npkts), $
    imon_p5va:bytarr( npkts), $
    imon_n5va:bytarr( npkts), $
    imon_n8va:bytarr( npkts), $
    imon_p5vd:bytarr( npkts), $
    imon_p25vd:bytarr( npkts), $
    ignd:bytarr( npkts), $
    ivmon_p10va:bytarr( npkts), $
    ivmon_n10va:bytarr( npkts), $
    ivmon_p5va:bytarr( npkts), $
    ivmon_n5va:bytarr( npkts), $
    ivmon_p8va:bytarr( npkts), $
    ivmon_n8va:bytarr( npkts), $
    ivmon_p5vd:bytarr( npkts), $
    ivmon_p25vd:bytarr( npkts), $
    imon_esa28v:bytarr( npkts), $
    ivmon_esa28v:bytarr( npkts), $
    ivmon_act:bytarr( npkts), $
    imon_sma:bytarr( npkts), $
    ivmon_sma:bytarr( npkts), $
    ifge_hsk1:bytarr( npkts), $
    ifge_hsk2:bytarr( npkts), $
    imon_efi_board:bytarr( npkts), $
    imon_efi_x:bytarr( npkts), $
    imon_efi_y:bytarr( npkts), $
    imon_efi_z:bytarr( npkts), $
    imon_idpu:bytarr( npkts), $
    ivmon_idpu:bytarr( npkts), $
    ipcb_fet:bytarr( npkts), $
    idcb_fpgat:bytarr( npkts), $
    idcb_ssrt:bytarr( npkts), $
    idcb_gnd:bytarr( npkts), $
    idcb_3v:bytarr( npkts), $
    ipwrswitch:bytarr( npkts), $
    iactselect:bytarr( npkts), $
    iacttime:bytarr( npkts), $
    iattalloc1:bytarr( npkts), $
    iattalloc2:bytarr( npkts), $
    imtrstat:bytarr( npkts), $
    pwrspare:uintarr( npkts), $
    issr_mode:bytarr( npkts), $
    issr_eng:uintarr( npkts), $
    issr_quick:uintarr( npkts), $
    issr_survey:uintarr( npkts), $
    issr_pburst:uintarr( npkts), $
    issr_wburst:uintarr( npkts), $
    ieccctrl:bytarr( npkts), $
    ieccadr2:bytarr( npkts), $
    ieccsing:bytarr( npkts), $
    ieccmult:bytarr( npkts), $
    isuntime:bytarr( npkts, 3), $
    ispinperiod:bytarr( npkts, 3), $
    iphaserr:bytarr( npkts, 3), $
    idpu_pageadr: uintarr( npkts), $
    onesecmark:bytarr( npkts, 6) $
}


p = 0L
b0 = bytarr( pkt_size)

; this algorithm for random access to the last frac's worth of the packets
; in the file won't work with variable-length packets,

if keyword_set( frac) then begin
    message, /info, 'FRAC keyword ignored because of variable-length packets.'
;   i0 = floor( (1.0-frac)*(npkts - 1L)) > 0L
;   i1 = npkts -1L
endif else begin
    i0 = 0L
    i1 = npkts-1L
endelse

if keyword_set( verbose) then $
    message, /info, string( npkts, i0, i1, format='("npkts, i0, i1:",I5.5,",",X,I5.5,",",X,I5.5)')

point_lun, lun, i0*pkt_size

for i=i0,i1 do begin
    readu, lun, b0
    pkt_struct.clock[ i] = ulong64( b0[ 9] + $
       ul64_256*( b0[ 8] + $
       ul64_256*( b0[ 7] + $
       ul64_256*( b0[ 6]))))

    pkt_struct.subsec[ i] = ulong( b0[ 11] + 256UL*b0[ 10])


    pkt_struct.apid[ i] = b0[ 1] + 256UL*(b0[ 0] mod 8)

    pkt_struct.pseq_ctrl[ i] = b0[ 2]
    pkt_struct.apid_ctr[ i] = b0[ 3]

; translate pseq_ctrl and apid_ctr bytes to APID number.
    pkt_struct.pkt_num[ i] = pkt_struct.apid_ctr[ i] + 256UL*( pkt_struct.pseq_ctrl[ i] mod 64)

    if keyword_set( verbose) or ( not keyword_set( no_pctr) and (i mod 100 eq 1)) then $
       message, /info, string( i, npkts, pkt_struct.apid[ i], pkt_struct.pseq_ctrl[ i], pkt_struct.apid_ctr[ i], pkt_struct.pkt_num[ i], $
         pkt_struct.clock[ i], pkt_struct.subsec[ i], $
         format='("pnum:",I5.5,X,"of",X,I5.5,X,"APID:",Z4.4,X,"pseq_ctrl:",Z2.2,X,"apid_ctr:",Z2.2,X,"pkt_num:",Z4.4,X,"clock, subsec:",I15.15,X,I7.7)')

    if pkt_struct.apid[ i] ne expected_apid then begin
       message, /info, $
         string( pkt_struct.apid[i], expected_apid, format='("apid (current, expected):","(",Z4.4,X,Z4.4,")")')
         stop
    endif


    t_hdr = double( pkt_struct.clock[i] - dt_epoch) + double( pkt_struct.subsec[i])/(65536.0)  ; s.
    if keyword_set(daytime) then dt=0. else dt=3600.     ;Daylight Saving Time
    pkt_struct.t_hdr[ i] = t_hdr - 7*3600. - dt   ;West Time Zone

; unpack data into the arrays in the pkt_data structure.
    pkt_data.idpu_rstctr[ i] = b0[ 12]
    pkt_data.ienables[ i] = b0[ 13] + 256U*b0[ 14]
    pkt_data.idpu_version[ i] = b0[ 15]
    pkt_data.idpu_mode[ i] = b0[ 16]
    pkt_data.idpu_fgnd[ i] = b0[ 17]
    pkt_data.idpu_errcode[ i] = b0[ 18]
    pkt_data.idpu_errdata[ i] = b0[ 19] + 256U*b0[ 20]
    pkt_data.idpu_errctr[ i] = b0[ 21]
    pkt_data.idpu_cmdreg[ i] = b0[ 22] + 256U*b0[ 23]
    pkt_data.idpu_cmdexp[ i] = b0[ 24]
    pkt_data.idpu_cmdtot[ i] = b0[ 25]
    pkt_data.idpu_loadadr[ i] = b0[ 26] + 256U*b0[ 27]
    pkt_data.idpu_dumpadr[ i] = b0[ 28] + 256U*b0[ 29]

    for j=0L,15L do $
       pkt_data.imemdump[ i, j] = b0[ 30 + j]

    pkt_data.io_fpga[ i] = b0[ 46]
    pkt_data.io_vc2cnt[ i] = b0[ 47]
    pkt_data.io_vc3cnt[ i] = b0[ 48]
    pkt_data.io_dcbctl[ i] = b0[ 49]
    pkt_data.io_auxstat[ i] = b0[ 50]
    pkt_data.io_uartstat[ i] = b0[ 51]
    pkt_data.itm_enable[ i] = b0[ 52]
    pkt_data.itm_errors[ i] = b0[ 53]
    pkt_data.imon_p10va[ i] = b0[ 54]
    pkt_data.imon_n10va[ i] = b0[ 55]
    pkt_data.imon_p5va[ i] = b0[ 56]
    pkt_data.imon_n5va[ i] = b0[ 57]
    pkt_data.imon_n8va[ i] = b0[ 58]
    pkt_data.imon_p5vd[ i] = b0[ 59]
    pkt_data.imon_p25vd[ i] = b0[ 60]
    pkt_data.ignd[ i] = b0[ 61]
    pkt_data.ivmon_p10va[ i] = b0[ 62]
    pkt_data.ivmon_n10va[ i] = b0[ 63]
    pkt_data.ivmon_p5va[ i] = b0[ 64]
    pkt_data.ivmon_n5va[ i] = b0[ 65]
    pkt_data.ivmon_p8va[ i] = b0[ 66]
    pkt_data.ivmon_n8va[ i] = b0[ 67]
    pkt_data.ivmon_p5vd[ i] = b0[ 68]
    pkt_data.ivmon_p25vd[ i] = b0[ 69]
    pkt_data.imon_esa28v[ i] = b0[ 70]
    pkt_data.ivmon_esa28v[ i] = b0[ 71]
    pkt_data.ivmon_act[ i] = b0[ 72]
    pkt_data.imon_sma[ i] = b0[ 73]
    pkt_data.ivmon_sma[ i] = b0[ 74]
    pkt_data.ifge_hsk1[ i] = b0[ 75]
    pkt_data.ifge_hsk2[ i] = b0[ 76]
    pkt_data.imon_efi_board[ i] = b0[ 77]
    pkt_data.imon_efi_x[ i] = b0[ 78]
    pkt_data.imon_efi_y[ i] = b0[ 79]
    pkt_data.imon_efi_z[ i] = b0[ 80]
    pkt_data.imon_idpu[ i] = b0[ 81]
    pkt_data.ivmon_idpu[ i] = b0[ 82]
    pkt_data.ipcb_fet[ i] = b0[ 83]
    pkt_data.idcb_fpgat[ i] = b0[ 84]
    pkt_data.idcb_ssrt[ i] = b0[ 85]
    pkt_data.idcb_gnd[ i] = b0[ 86]
    pkt_data.idcb_3v[ i] = b0[ 87]
    pkt_data.ipwrswitch[ i] = b0[ 88]
    pkt_data.iactselect[ i] = b0[ 89]
    pkt_data.iacttime[ i] = b0[ 90]
    pkt_data.iattalloc1[ i] = b0[ 91]
    pkt_data.iattalloc2[ i] = b0[ 92]
    pkt_data.imtrstat[ i] = b0[ 93]
    pkt_data.pwrspare[ i] = b0[ 94] + 256U*b0[ 95]
    pkt_data.issr_mode[ i] = b0[ 96]
    pkt_data.issr_eng[ i] = b0[ 97] + 256U*b0[ 98]
    pkt_data.issr_quick[ i] = b0[ 99] + 256U*b0[ 100]
    pkt_data.issr_survey[ i] = b0[ 101] + 256U*b0[ 102]
    pkt_data.issr_pburst[ i] = b0[ 103] + 256U*b0[ 104]
    pkt_data.issr_wburst[ i] = b0[ 105] + 256U*b0[ 106]
    pkt_data.ieccctrl[ i] = b0[ 107]
    pkt_data.ieccadr2[ i] = b0[ 108]
    pkt_data.ieccsing[ i] = b0[ 109]
    pkt_data.ieccmult[ i] = b0[ 110]

    for j=0L,2L do begin
       pkt_data.isuntime[ i, j] = b0[ 111 + j]
       pkt_data.ispinperiod[ i, j] = b0[ 114 + j]
       pkt_data.iphaserr[ i, j] = b0[ 117 + j]
    endfor

    pkt_data.idpu_pageadr[ i] = b0[ 120] + 256U*b0[ 121]

    for j=0L,5L do $
       pkt_data.onesecmark[ i, j] = b0[ 122 + j]

endfor  ; for i=... loop over packets in file.

free_lun, lun

return
end