// P R I N T // errors 1000 // get "Spruce.d" get "SpruceFiles.d" get "Orbit.d" // outgoing procedures external [ DrivePrinter ] // incoming procedures external [ SpruceError Max Min InitRam //SprucePrint AddToBin Announce AwaitPageSync PrintNext ReadBands ReadClock ReadFont //CURSOR CursorChar CursorDigit // SprucePrintRes DoFunc ROSStatus // Timer (debug only) SetTimer TimerHasExpired //OS Zero DisableInterrupts EnableInterrupts ] // incoming statics external [ scanTicks // # of 38 usec. ticks in 4 printer scan lines. logBandRecordSize bandRecordSize nPagesPrinted printerForward Debug DebugSystem signalBand Func debugTrail knockResult numPrinted numMustPrint InitMeasure // Dover engine control monitoring stuff CloseMeasure TickMeasure Measure measureTable xmFonts // Font data will be read into Bank 1 via Bank 0, if set nRecs LowAdr FAvalue nBands stopsPrinting ] // internal statics static [ timeOut=15*27 printHysteresis = 15 // print this many before allowing suspension, each time in // ~~ above number may want to increase for large runs, or something? // sFix ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // sFix ~~ At present, Sequoia "not ready" bit never presents itself // sFix ~~ Some print sequences require an engine runout, followed // sFix ~~ by a restart -- this delay waits for shutdown before continuing readyTimeOut // sFix ~~ set 0 at start, non-zero for outer loop continuation sReadyTimeOut=2*27+20 // sFix ~~ can tune this from Swat until it's right // sFix ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // delay ~~~~ debugging: delay per page to simulate printing debDelay = 0 // delay no delay std. // delay ~~~~ ] // File-wide structure and manifest declarations. manifest [ RTC=#430 debugTrailSize = 10*3 // Failure Code ranges -- see ROSCheck maxNotReady = 9 // not ready, but probably will be soon maxManual = 19 // Manual intervention required maxJam = 99 // Error during operation minDocumentError = 300 // Document inherently hard to print ] // ROSCheck values structure CT: [ invert bit 1 // bit is on when things are good malFnReq bit 1 // Dover malfunction bit must also be on or no error failureCode bit 6 wordIndex bit 4 bitIndex bit 4 ] manifest // factors for creating table entries [ Invert = #100000 MalFnReq = #40000 Code = 256 Word = 16 Bit = 1 ] // ----------------------------------------------------------- // Print Initialization // ----------------------------------------------------------- // Returns -1 if printing is successfully completed, else // nPagesPrinted, so can pick up where we left off. let DrivePrinter(pDoc, nPagesAlreadyPrinted, lvFailureCode) = valof [ // ******** See SpruceMeasure -- don't move declarations of next five local variables ******** let malfunction, proceedCode, nonF, coldStart, consecutiveErrors = 0, 0, 0, 0, 0 // ******** let CommTab=vec 10 CommTab=(CommTab+1)&(-2) // If monitoring performance, these are real InitializeHardware(false) InitMeasure(measureTable, 2000, (lv malfunction)-1) consecutiveErrors=0 let knockKnock = false // time to let somebody in if true let stopPrint, okPrint = #60000, #60001 // Print (cont.) Slow Loop // Loop out to here when a new font set is required, or when // needing to completely restart the printer. [Slow // Find out which page to print next: let copy = nil let page=PrintNext(pDoc, lv copy, nPagesPrinted) if page eq 0 then [ knockKnock = false; break ] if knockKnock then break // go let somebody in // Read in font and relocate the pointers to characters: let font=page>>PageG.fontLoad*(size FontG/16)+pDoc>>DocG.Fonts // Next call returns location of ICC table, let FontTable = ReadFont(font, LowAdr, nRecs) unless xmFonts do for i=0 to pDoc>>DocG.ICCtotal-1 do // if rasters are in bank 1, they start at 0 FontTable!i=FontTable!i + LowAdr FontTable=FontTable-100000b // Figure out where buffers are. let nRecords= xmFonts? (pDoc>>DocG.ICCtotal+bandRecordSize-1) rshift logBandRecordSize, font>>FontG.nRecords let nfRecs=(nRecs-nRecords)/2 // max allowable band list size for normal alternation let LeftOver = LowAdr+(nRecords lshift logBandRecordSize) let LeftOverGuard = LeftOver+(loSize&(-4))-4 let buf1 = (LeftOver+loSize+8)&(-2) // ~~ all the 4's, 8's and 10's in here are cowardly slack let buf2=buf1+nfRecs lshift logBandRecordSize let curbuf= buf1 // first real data imaged from buf1 // Now read in the bands for this page ReadBands(page, curbuf, nfRecs*2) // Initialize the Orbit, etc. InitializeHardware(false) let np = nil let tim = @RTC // Check for problems, wait for ready indication // wait for ready or some serious condition or for long enough unless Debug do // sFix ~~~~~ possibly wait for shutdown ~~~~~~~~~~~~~~~~~~ [ // sFix ~~~~~ while (@RTC-tim) < readyTimeOut loop readyTimeOut = sReadyTimeOut // sFix ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [ np = ROSCheck(lvFailureCode, nPagesAlreadyPrinted, false) if np eq -1 break // ready if @lvFailureCode > maxNotReady % (@RTC-tim) > timeOut resultis np ] repeat ] // sFix ~~~~~ // Try to empty Orbit buffers to clear them. This is to minimize // toner dumping on first (blank) page. compileif loSize ls 256 then [ foo=nil ] for i=0 to 31 do DoFunc(fReadBlock, 256, LeftOver) // Now feed first sheet: DoFunc(fControl, 21b) DoFunc(fROSCommand, adBufferReset) FeedASheet() AwaitPageSync(0) //Wait for sendVideo to go off. // Print (cont.) Fast Loop [RunningLoop // Calculate a ROS command table for the device: CommTab!0=signalBand CommTab!1=stopPrint //Stop unless proven otherwise (below) CommTab!2=-1 // Start Orbit working on the present page. DoFunc(fControl, #21) //Reset, clear behind DoFunc(fROSCommand, adBufferReset) LeftOver!0=0 //Initialize LeftOver table LeftOverGuard!1=-1 tim=@RTC // Start the microcode!!!! DoFunc(fSlot, CommTab, 20000, nBands-1, FAvalue, LeftOver, FontTable, curbuf-1, nil, nil, (copy lshift 5)+4) if Debug then // ~~delay [ // ~~delay while (@RTC-tim) < debDelay loop // ~~delay tim = @RTC // ~~delay don't invoke timeout code below ] // ~~delay // Proceed code: // 0: Charge on ahead, full speed // 1: Pause because cannot fit bands or font for next page, // or because printing is done. // Assume the page we are printing will be OK: nPagesPrinted=nPagesPrinted+1 CursorDigit(nPagesPrinted) // See who's (maybe) knocking at my door // This logic is copied from SpruceUtilsRes: if we are not planning to defer to spooler, // don't trouble to shut down here, just to find that out there. Would be too expensive if (DebugSystem) eq 0 & numPrinted ge numMustPrint & knockResult & (nPagesPrinted-nPagesAlreadyPrinted) > printHysteresis then knockKnock = true // Find next page to work on: proceedCode=1 let nextbuf=curbuf xor buf1 xor buf2 let nextPage=PrintNext(pDoc,lv copy, nPagesPrinted) if (not knockKnock) & nextPage then //Unless this page gets messed up we will continue printing. [ if (nextPage>>PageG.fontLoad eq page>>PageG.fontLoad) & (nextPage>>PageG.nRecords le nfRecs) then [ proceedCode = 0 // Read in the bands for the next page: CommTab!1=okPrint // don't stop ReadBands(nextPage, nextbuf, nfRecs) ] ] // Print (cont.) Wait for completion, analyze results // Now see if we actually printed this page properly. First, // wait for Orbit to announce it is finished. let imageTimeout = 10*27 while @#720 ne 0 do if (@RTC-tim) gr imageTimeout then [ Blast() // clear hardware, #720 // Machine dead or Orbit got behind and it wasn't detected // Will generally be overriden by more specific analysis @lvFailureCode = 19 // Manual intervention required break ] // Check Orbit status nonF = 0 let stat=Func!9 //Orbit printing status. // Fatal error detected by microcode -- invalid Band entry -- possibly broken processor if stat<<STATUS.invalidBandEntry then [ InitializeHardware(true); if LeftOverGuard!1 eq -1 then SpruceError(1010, @1, @2) //else, assume that //bad band entry is simply result of leftover overflow ] test stat<<STATUS.prematurePageAbort then [ Announce(16); nonF = 301 ] or if stat<<STATUS.behind then [ Announce(16); nonF = 300 ] if stat<<STATUS.timeout then [ Announce(17); @lvFailureCode = 18 ] if LeftOverGuard!1 ne -1 then [ Announce(18); nonF = 310 // then check possible next page data enclobberment if ((proceedCode&1) eq 0) & nextbuf eq buf1 then proceedCode = 1 ] if nonF then @lvFailureCode = nonF if (stopsPrinting eq binFull) & (@lvFailureCode eq nonF) then @lvFailureCode = 130 AddToBin(1500) // Now try for more specific engine status check np=ROSCheck(lvFailureCode, nPagesAlreadyPrinted, true) // Now wait for page sync to go off unless AwaitPageSync(0) then @lvFailureCode = 16 //Now decide what to do: if proceedCode then Announce(proceedCode) malfunction = @lvFailureCode if malfunction ge minDocumentError then malfunction = 0 // will not stop // Now react to the analysis: if at this point nothing is wrong and sheets are // feeding, steam ahead. Otherwise, return to the slow loop if data is not available // or if paper misfed. Return if there was a serious malfunction, or if things look // odd several times consecutively (paper failed to feed is the only case, for now) Measure(#23,(@(#123))+1) // force random event unless malfunction do [ if proceedCode eq 0 then [ curbuf=nextbuf consecutiveErrors=0 loop ] if proceedCode eq 1 then break //Out of RunningLoop ] Measure(#23,(@(#123))+1) // force random event InitializeHardware(true) // if malfunction detected outside of ROSCheck, set np if np eq -1 then np = nPagesPrinted-1 // account for previous increment np = Max(np-1, nPagesAlreadyPrinted) CloseMeasure() // if measure code loaded, this is real, else dummy resultis np ]RunningLoop repeat ]Slow repeat InitializeHardware(true) CloseMeasure() resultis (knockKnock % @lvFailureCode)? nPagesPrinted, -1 ] // -------------------------------------------------------------------------- // nPagesPrinted = ROSCheck(lvFailureCode, nPagesAlreadyPrinted, running, ) // -------------------------------------------------------------------------- // analyze ROS status // nPagesPrinted = -1 if there are no malfunctions, ROS is ready to print // otherwise, the number of pages to report as having been printed // @lvFailureCode will contain an analysis of the current state. The code values are // described below. // nPagesAlreadyPrinted places a lower bound on the nPagesPrinted result. This // prevents loops through this code from backing up too far. // running true if caller thinks main drive is allowed to be on for "ready" // result, false otherwise (waiting for ready). // ROSCheck first screens the current status for any malfunction indications, and // returns right away if there are none. Otherwise, it applies the current status // against a printer-dependent table of possible conditions, yielding a failure // code and a new page value -- the last page certain to have been reliably // printed. One possible condition is "no malfunction detected", which will only // be issued for printers that give no positive indication when they are merely // busy doing normal things. // N.B. @lvFailureCode is not changed when no conditions are found // The failure codes divide into ranges: // 0-9 Not ready, but no indication of problems or will clear up automatically // (includes fuser cold, warmup mode, clearing revolutions, etc.) // 10-19 Manual intervention required before machine can become ready // (paper low, power not there, etc.) // 20-99 Jams and other operational malfunctions (many codes provided so that // each device can report machine-dependent jam explanations) // 100-200 Inherent problems (e.g., insufficient bandwidth somewhere) that are // not curable by mere mortals. Attempts to improve the situation should be // abandoned. // 200-300 Inherent problems encountered, but they did not terminate printing. One // should expect that one or more pages were improperly imaged. // The machine-dependent control table is constructed using this pattern: // structure CT: // [ // invert bit 1 // failureCode bit 7 // wordIndex bit 4 // bitIndex bit 4 // ] // invert means that the bit is on when the condition is not a problem (e.g., "Ready") // failureCode should be reported when the condition specified by the bitIndex'th // bit inROS status word wordIndex is a problem. // (Pimlico and Puffin use a different format: // right byte is status code returned from machine, // left byte is status code returned from ROSCheck // A check, designed chiefly for Dover, verifies that the laser is on and the polygon is // scanning (SOS/EOS are seeing things), by making sure that the low four bits of the line // count (indicated in status word) are changing. The code reads the line count, waits // approximately the time needed for four scan lines (generous margin), then reads the // count again, reporting a problem if the values are equal. This test happens only when // the running parameter is false. The wait time (scanTicks) is computed in PrintInit, as: // ResolutionS is scaled by 10 as stored, PaperSpeedInches by 100. The (fast 10 bits of) // the RTC ticks at 38 usec. intervals. Thus the # ticks wanted for four lines is: // ( 4 lines x 10↑6 usec/sec x 1/38 tick/usec.) / ((PaperSpeedInches/100 x ResolutionS/10) lines/sec) // or about (106 x 10↑3) / (PaperSpeedInches/100 x ResolutionS/10) ticks -- about 30 for Dover. // This is only approximate because ROSStatus time, about 10 ticks for Dover, is not included. // Part of the reason for waiting four line times is to account for possible delays in obtaining // the correct line count status. Later, this method can be used to check for correct polygon speed. // The scanTicks static is shifted left by 6 to match the clock reading function's results // ROSCheck (cont) and ROSCheck(lvFailureCode, nPagesAlreadyPrinted, running) = valof [ let ros8 = ROSStatus(8) let ros9 = ROSStatus(9) let localMode, scanning = nil, true let seqStatus, malFnStatus = nil, nil // ready if not in local mode and if printer-specific tests indicate ready let ready = (ros9&(running? #100, #300)) eq 0 if ready then [ localMode = (ROSStatus(0)丠) ne 0 unless running do [ let lineCount = ROSStatus(7) & #170000 let rtc = ReadClock() until (ReadClock()-rtc) ge scanTicks loop scanning = (ROSStatus(7)𩠐) ne lineCount ] if localMode % not scanning then ready = false ] if ready % Debug resultis -1 // Analyze tables to identify the problem or condition preventing ready let tab = table [ 4*Code + 8*Word + 13*Bit // Fuser not warm 10*Code + 8*Word + 5*Bit // Check paper tray 30*Code + 9*Word + 2*Bit // Jam 31*Code + 9*Word + 9*Bit // Unexplained Malfunction 1*Code + 9*Word + 8*Bit // Not ready 0 ] let bits = table [ #100000; #40000; #20000; #10000 #4000; #2000; #1000 #400; #200; #100 #40; #20; #10 #4; #2; #1 ] let code = 0 while @tab do [ let entry = @tab let isBit = (ROSStatus(entry<<CT.wordIndex) & bits!(entry<<CT.bitIndex)) ne 0? 1, 0 if isBit ne entry<<CT.invert & (entry<<CT.malFnReq eq 0 % (ros9d) ne 0) then [ code = entry<<CT.failureCode; break ] tab = tab + 1 ] // No other explicit problems, report local mode, or laser off, or unknown problem unless code do code = localMode? 11, scanning eq 0? 13, 7 @lvFailureCode = code let backup = code le maxManual? 0, code < 30? 2, 1 resultis Max(nPagesAlreadyPrinted, nPagesPrinted-backup) ] // ----------------------------------------- // Engine controls of various sorts. // ----------------------------------------- and FeedASheet() be [ DoFunc(fROSCommand, 60000b) DoFunc(fROSCommand, 60001b) ] and InitializeHardware(stop) be [ if Debug return InitRam(0) //Reset all RAM tasks, restart Trident if necessary DoFunc(fControl, 1) //Reset Orbit if stop then DoFunc(fROSCommand, 60000b) ] and Blast() be InitializeHardware(false) // May 22, 1979 1:16 PM first cut // February 2, 1981 4:32 PM, don't swat if bad band entry probably due to leftover overflow