CA1177147A - Automatic position control system for slitters - Google Patents

Abstract

ABSTRACT OF THE DISCLOSURE
An automatic position control system for a slitter longitudinally slits a sheet of material into a plurality of strips. Each slitter assembly has an upper and lower slitter station which can be moved transversely of the web to be cut and includes a main control computer. Each positioning assemb-ly includes an electronic communication module, an electronic stepping motor drive module, and a stepping motor gear box and pinion assembly for moving the slitter assembly. Each electronic module recognizes when the main control computer is communicating with that module by recognizing its selectable identification address. Communication can occur in either direction between the electronic modules and the central computer. The main control computer can command an electronic module to carry out specific functions and also can request information from the electronic module concerning its status at a particular time. Control information can also be supplied to the central computer which can in a very rapid and orderly manner move the slitter assemblies to desired locations. A
novel communication bus structure is utilized to position the mechanical assemblies.

Description

~`` 13L~71~7 This invention relates in general to slitters for longitudinally cutting webs of paper or other material into a plurality of longitudinal strips and in particular relates to an automatic position control system for slitters.
Conventional w~nders re~uire that slitter assemblies be positioned by hand. This is an inaccuraté method of positioning slitters. The time required to move slitter assemblies is substantial when they are positioned by hand and thus it is desirable to move and index such sIitter assemblies more accurately for saving time for cutting and winding paper. Prior art slitter systems are described in U. S. Patent No. 3,176,566 and Canadian Patent No. 1,043,004.
The present invention comprises an automatic position control system for slitters which operates under computer control so as to position slitter assemblies accur- ~;
atel~ and quickl-~. A Gentral control computer interrogates and controls several electronic modules each located on a positioning assembly and in a particular example, 80 elec-tronic modules were utilized all of which were connected to the same sixteen wires.
~ ore specifically, th~e present invention provides an automatic position control system for slittersor divid-ing a moving web, comprising upper and lower rails mounted above and below said moving web, upper and lower racks, respectively, mounted on said upper and lower rails, a plurality of upper slitter stations with cutters mounted on said upper rail and having driving gears which engage said upper rack, a plurality of lower slitter stations with cut-ters mounted on said lower rail and having driving gears which engage said lower rack and said upper and lower slit-ter stations arranged in associated pairs so as to cut said web, a plurality of motors with one in each upper and iower slitter station and connected to said driving gears to'move said upper and lower slitter stations on said upper and lower rails, a plurality of electronic control modules with different addresses and one in each upper and lower slitter station respectively, connected to one of said plurality of motors, a main control computer, an address and data bus connected between said main control computer and each of said electronic control modules for the addressing of indi-vidual modules and for the transfer of data signals between said computer and said modules so addressed, and means for supplying command signals to said control computer to cause it to transmit commands and position data on said bus to -qelected module addresses to cause said motors to position said upper and lower slitter stations.
Each of the electronic modules can recognize its address when the main control computer desires to communicate ... .. . . .

.

, -~L77:1~7 with that particular module. Each electronic communication module has a switch selectable identification number address which is unique to that particular module. The main control computer determines with which module it desires to communicate and addresses that module to initiate the communication. Such communication can be in either direction in that the main control computer can command an electronic module to carry out specific functions and can also request information from an electronic module so as to determine its status at a particular time.
By communicating and issuing orders with a number of electronic modules in an orderly fashion under a computer program the main control computer systematically controls and moves assemblies to the desired locations.
The use of bus conductors in the machine tool and slitter industries to position large numbers of independently powered mechanical assemblies is novel.
An example of a typical communication sequence required to position mechanical assemblies is as follows. I~
the main control computer desires to move a particular assembly 8" to the right and a second assembly 4" to the left, the following is an illustration of the manner in which the system of the ~nvention accomplishes this task, 1. The main control computer (MCC~ sends a signal to the electronic module ~EM) in the first assembly to enable itself for acceptin~ communication.

2. The main control computer issues a signal to a first electronic module to enable itself for a move in the direction to the right.

3. The main control computer informs the second module to enable itself to accept communication.

4. The main control computer issues instructions to the second module to enable itself for a move in the left direction.

77~

5. The main control computer generates step com-mands to move both of the modules 4" inches (800 steps).

6. The main control computer tells the second module to enable itself to accept communication.

7, The main control computer tells the second module to disconnect itself since it has moved the total of 4" which was required.

8. The main control computer knowning that it must move the first module another 4 M and also knowing that it has already disconnected the second module so that it will not move any further generates the remaining step commands and supplies them to the first module to move it the remaining 4".

9. The main control computer informs the first electronic module to prepare itself to accept a communication.

10. The main control computer informs the first module to disconnect itself since ;ts move has now been completed.

11~ The main control computer then proceeds with other business as do the various electronic modules.
;~ ~; 20 The total time for completing steps 1, 2~ 3, 4, 6, 7, 9 and l0 is about 0.0005 seconds. Steps 5 and 8 each take about 1 ~econd (assuming movement is approximately 4" per second~, ~ If a slitter machine had five stations, the time to ; ~move all five stations to ne~ positions for the next cut~ takes ahout 10 seconds. This is in contrast to conventional winder machines wherein the Setup of five stations to new positions takes up to lQ minutes~ Thus, the invention provides su~stan-t~al savings and~time over systems of the prior art.
Other o~jects, features and advantages of the invention will ~e readily apparent from the following description of certain preferred embodiments thereof taken in conjunction wlth the accompanying drawings although variations and modifica-tions ma~ ~e effected without departing from the spirit and scope of the novel concepts of the disclosure and in which:

17~4~ , BRIEF DESCRIPTION OF THE DRAWINGS
. ~
Figure 1 is a front plan view of kwo slitter stations;
Figure 2 is an electronic block diagram illustrating a central computer and its connection to various modules;
Figure 3 is a block diagram of the positioner module; and Figures~ through 59 comprise flow diagrams of the control system.

DESCRIPTION OF THE PREFERRED EMBODIMENTS
_ Figure 1 is a front plan view of two slitter stations of a slitter machine according to the invention which can be used, for example, for longitudinally slitting paper or other material. The first slitter station 40 comprises an upper slitter station which moves on a rail 10 that is provided with a rack 11 ~or indexing purposes. A housing 16 is movably mounted on the rail 10 and carries a frame member 13 with a cutting blade 12 for the top slitter station 40, A gear box, ; 18 carries a gear which mates with the rack 11 and receives an input from a motor 19 such that when the motor 19 is energized the housing 16 and the associated blade 12 can be moved longi-20~ tudinally along the rail 10. A top slitter station electronicmodule 50 is carried by the housing 16, A lower rail 27 has a rack 28 and a band 14 which mates with the blade 12 to shear the paper at the surface between the blade 12 and the band 14 is carri-ed by a ~rame member 25 wh;ch also supports a motor 29 for driving the band and carries gear box 31 and a motor 32 which -is connected to a gear that mates with the rack 28 for moving the band transversely on the rail 27. A bottom slitter station 6Q contains an electronic module for controlling the band 14.
A second top slitter station 80 carries a blade 21 which is mounted on the frame 22 that is supported on the member 23 that IS mounted for movement relative to the rail 10.

~5-~ ~7 731 47 A gear box 24, motor 26 and top slitter electronic module 42 are carried by the frame member 23. A lower slitter station 85 carries a band 33, motor 34 and has a frame member 30 which is movable transversely of the rail 27. A
motor 37 and gear box unit 36 and a bottom slitter elec-tronic module 43 complete the lower slitting station 85.
It is to be realized of course that a number of other top and bottom slitter units may be mounted and carried by the rails 10 and 27.
Figure 2 illustrates the communication and power arrangement between a control computer 53 which is located at an operator console 80 which also has a monitor 51 and input buttons or keys 52. The control computer 53 is con-nected to each of the top and bottom slitter stations 50, 42, 90, 60, 43 and 95 as illustrated in Figure 2 by a data and address bus 55 and a power bus 54. In a particular system constructed according to the invention, a data and address bus comprised 10 wires and the power bus 54 com-prised six wires. As shown in Figure 2, the data and ad-dress bus is connected by segment 64 to top slitter station 50, segment 67 to top slitter station 42, segment 69 to :
top slitter station 90 as well as by segments 63, 66 and 68 to bottom slitter stations 60, 43 and 95. The power bus is connected by segments 57, 59 and 62 to the top slit-ter stations 50, 42 and 90, respectively and by segments 56, 5~ and 61 to the bottom slitter stations 60, 43 and 95.
Figure 3 is a detail view of the top slitter sta-tion 50 which comprises an electronic communication module 71 which is connected by segment 64 of data and address bus 55 with the control computer 53 as well as with its associ-ated bottom slitter station 60 as well as with the other modules. The eIectronic communication module 71 also ;i 7~47 receives an input on se~ment 57 of power bus 54 and sup-plies output to a step motor drive 72 which is connected to a step motor 19 which moves the blade 12 reIative to the rail 10. An encoder 73 provides a feedback signal to the electronic communication module 71. A home limit switch 74 also supplies an input to the electronic communi-cation module 71 and a manual move switch 76 directly pro-vides an input to the electronic communication module 71 to move the blade 12 manually. A blade wear switch 77 also provides an input to the electronic communication module.
Each electronic module has the capability of recognizing when the control computer 53 wishes to communi-cate with that particular module and each electronic module has a switch selectable identification number or address which is unique. The control computer decides which module it wishes to communicate with, addresses that module, then communicates with that module. This communication can be in either direction. The control computer can command an electronic module to accomplish a specific job and can also ask an electronic module questions concerning its status at a particular time. By communicating with a num-ber of electronic modules in an orderly fashion the control computer systematically moves the cutter blades and associ-ated bands to desired locations. Further details of the operation of a preferred embodiment of the control computer and the electronic modules for both the top and bottom sta-tions will be apparent from reference to the following pro-gramj and its accompanying commentary and flow diagrams.
In this embodiment, the control unit comprises a main pro-cessor, which communicates with the operator via the monitor51 and keypad 52, and with an 8085 control processor via certain specific addresses in the memory associated with 7~14~
the latter. The assembly language source statements included in the program are written using 8080 operation code -mnemonics. The program for the main processor is not included since it essentially acts to provide a termi-nal providing an interface between the control processor and the operator, and the format of the data to be trans-mitted between the processors is apparent from the program for the control processor.

AUTO POSITION SLITTERS
MONITOR AND COMMUM CATION PROGRAM

The function of the following set of routines is to monitor the status of all the modules of an auto posi-tion slitter unit, and to e~ecute any motions requested by either the main processor or by the modules themselves.
The program operates through the following principles:

1) A monitor program continuously checks the status of all modules, and executes various updating rou-tines based on the status read;

2) The main processor (a Z80) communicates : :
with the modules through an 8085 control processor. Any attempt to read or write information generates an interrupt ~in~the control processor. The interrupt handling routines in this program process these requests and then return to the monitor routine;

~ :, 3) Both (1) and (2) utilize a common pool of subroutines.

' :: :
,.

~ ~:1 7719~7 MEMORY MAP:
I) ROM ADDRESSES 0000 TO 07FF

002C - INTERRUPT 5.5 0034 - INTERRUPT 6.5 003C - INTERRUPT 7.5 II) RAM (ADDRESSES 0800 to OBFF) 0900 TO 09FF - FUTURE POSITION ARRAY ~:

0All - STATB

; OA16 - NUMON :

~: ~20 OAl9 - LOSS
: OBFF - INITIAL TOP OF STACK
III) SPECIAL PURPOSE -ADDRESSES
1400 = DATAB
; ~ 1800 = ALSB
lFF2 = ;COMM
lFF4 = SWTCH
V A~R I A B L E S:
PRESENT POSITION ARRAY
This is an array which holds the positions of all of the modules. Positions are measured in units of pulses from the home position ~1 pulse = .-005 lnches). All positions are positive and require two bytes. However, since modules move in pairs only one position is required ~z .
_9_ : . , .

: ~: ' - , ------~
77~47 for every two modules.
Positions ~re stored least significant byte first most significant byte second.
Example:
If module #7 is A010 pulses from home, then the seventh byte in the array is 10, and the eighth byte is A0.
FUTURE POSITION ARRAY
This array is identical to the present position array, except it contains the future positions of the module pairs. When a move is executed, all modules move to their ~ ~
future positions. ~`
AUTO MOVE REQUEST A~RAY
This is a 10H byte array in which each bit corres-ponds to a different module pair. (Bit zero on the first byte corresponds to modules 0 and 1, bit one to 2 and 3, etc).
This bit is set if a particular module pair is to be moved.
It is set when the future position is entered, and reset after the move. ~ -;20 N
This byte stores the total number of modules on line. ~;
STATB
~ This byte stores the status of a givan module, the :
meaning of the various bits of a status byte is given at ~he end of this section.
CONTB
;: :
This byte holds the command to be given to a module.
The function of the various bits of a control byte is given at the end of this section `~
; ~ 30 LATCH

This byte is used to indicate various internal states of the program. The function of the various bits of the latch byte is given at the end of this section.

: : ... . . : : ., .. .. . . .
:. . ~ , . .

71~L~
MODNM
This byte holds the module number which the main processor is concerned with. For example, if the mai~ pro-cessor requests to enter a future position, it is entering the future position of module number MODNM.
NPAIR
This byte holds the first even number which is greater than or equal to N. This variable ensures that all modules move in pairs.
NUMON
This byte holds the number of modules which must move. When this byte is zero, all modules have moved to their future positions.
SMALL
This is a two byte variable used to store the smallest distance any module has to move. The least signi-ficant byte is stored in SMALL, and the most significant is stores in SMALL + 1.
LOSS
This is a two byte variable which holds the two's complement of loss. The LSB is stored in LOSS, and the MSB
is stored in LOSS ~ 1.
DATAB
This is the data bus for the main processor. Any time the main processor requests to read or write informa-tion, the data should be transferred to or from DATAB.
ALSB
This is the least significant byte of the address bus of the main processor. In the main processor, reading to and writing from specific memory locations should cause the 8085 to perform specific functions. The data in ALSB
should indicate to the 8085 which function to perform.

1~7714~

COMM
This memory location i~ used to communicate with the modules.
SWTCH
This memory location i8 used to enter the number of pulses which the pulse generator should produce. The least significant byte is ~ntered at SWTCH, and the most significant byte is entered at SWTCH ~ 1. Entering the most significant byte causes the pulse generator to begin 10 generating pulses.

STATUS BYTE~
I 7 I 6 I 5 I 4 I 3 I 2 I l I 0 I
I I I I I I I I I -BIT # O - FAULT (1 = FAULT OCCURRED) - "
.
: 2 - HOME (1 = MODULE IS HOME) 3 -- LOCAL CUTTER DISABLE (1 = DISABLED) ~ BIT 4 SET BY 8085 4 - AUTO MOTION COMPLETED (1 = DONE) ;~ : 5 -. MANUAL MOVE REQUEST LEFT (0 = REQUEST) 6 - MANUAL MOVE REQUEST RIGHT (0 = REQUEST) 7 - TEST BIT :~

. . . _ I I I I I I I I I
: ~ :20 CONTROL BYTE: I 7 I 6 I 5 I 4 I 3 I 2 I 1 I 0 I
: I I I I I I I I I
~ : BIT # 0 - ~
: 1 - GRANT REQUEST LEFT (0 = REQUEST GRANTED) .
: 2 - GRANT REQUEST RIGHT (0 = REQUEST
GRANTED) : 3 - DISABLE CUTTER REMOTE (1 = DISABLED) - CONNECT MODULE LEFT (1 = CONNECT) 6 - CONNECT MODULE RIGHT (1 = CONNECT)

-12- '~

.;
-: `, ' . ~ ' i 1~771~
:

I I I I I I I I I
LATCH BYTE: I 7 I 6 I 5 I 4 I 3 I 2 I 1 I 0 I
I I I I I I I I I
BIT `# 0 - MANUAL MOVE (l = MANUAL MOVE IN PROGRESS) 1 - MANVAL MOVE FAIL (1 = FAULT ON MANUAL MOVE) 2 - FAULT READ (0 = FAULT ACKNOWLEDGED) 3 - AUTO MOVE (1 = AUTO MOVE IN PROGRESS) 4 - READ ERROR (l = READ ERROR OCCURRED) 5 - WRITE ERROR (l = WRITE ERROR OCCURRED) 6 - MANUAL MOVE RIGHT (l = LAST MANUAL MOVE
WAS TO THE RIGHT) ; VARIABLES AND INITIAL DATA

PRES: DS 100H
FUTR: DS 100H
AUTMV: DS 10H
N: DB 00H
STATB: DB 00 : CONTB: DB 0OH
LATCH: DB 00H
;~ MODNM: DB 0OH
: : .
2~ NPAIR: DB i 00H
`
:~ :NUMON: DB 00H
SMALL: DW OOOOH
LOSS: DW 0000H
TOP EQU OBPFH
COMM EQU lFF2H

DATAB EQU i400H
SWTCH EQU lFF4H
END

.

~77147 . . .

; V E C T O R S ~
;

JMP STRT ; START

ORG 002CH ~ :~
JMP RINT ; RESTART 5 . 5 JMP WINT ; RESTART 6 . 5 : `

JMP PINT ; RESTART 7 . 5 MAIN PROGRAM
The purpose of this program is to enable the 80 85 :~
processor to monitor the status of the positioning modules , of the auto-position slitters. This is accomplished by checking the status of each slitter in turn. If a fault (any kind of unexpected motion or lack of motion) is detected, this processor interrupts the main processor and reports the fault. If a module sends a manual move request (a local attempt to move the module), both the module and its partner are moved until either a fault is detected or the manual move is completed.
~`:
This routine also records the position of the modules in an array known as the "present position array". `~
If a module's status indicates that it is in the home posi-tion (defined by a~switch in the module) then its position lS set to zero. After a manual move, the distance the module moved is either added or subtracted (depending on the direc-tion of motion) to its present position.
Note that because this is a monitor program, it does not terminate but continuousl~ cycles.
Subroutines called:-BREAK
COUT
CPOUT
FOUT

~ :

~L17~ 7 . . i pART
PPADD
PULSE
SIN
SPI~
UPDAT

; INITIALIZATION
STRT: LXI SP,TOP
MVI : A,08H
DB 30H ; UNMASK ALL INTERRUPTS
: X~A A
STA LATCH
STA N
STA STATE
: STA CONTE
: STA MODNM
:
: STA NPAIR -~
: STA : NUMON
2~0~ MUI B,lOH
LXI H,AUTMV
MCLR:~ ~OV : M,A ; CLEAR AUTO MOVE REQUESTED ARRAY
INX : H
; OCR B
~:: :
~ ~ JNZ MCLR
.
: ; MAIN ROUTINE
EI
.
: ~ ~ MAIN: LDA N ; WAIT UNTIL N IS NOT ZERO
ANA A , (THROUGH AN INTERRUPT) : 30 : JZ MAIN ~-.
X ~:
: ~
.. . .
. - .: -~1~7719~7 .

MOV B,A ; SET B TO HIGHEST MODULE
NUMBER :
MNEXT: DCR B ; (B) = CURRENT MODULE NUMBER
CALL SIN ; CHECK STATUS OF MODULE B ~
LDA STATE : ~ :
ANI 01H ; ANY FAULTS DETECTED
JNZ MFALT ; IF YES, GO TO MFALT
LDA STATE
CMA
ANI 6OH ; IS A MANUAL MOVE REQUESTED?
JZ M0 ~ :~
CPI 60H ~ -JNZ MANMV ; IF YES, EXECUTE IT
MO: LDA STATE
ANI 04H ; IS THE MODULE IN HOME POSITION? ;:
: JZ Ml ; IF NO, GO ON TO NEXT MODULE ;~-.
CALL PPADD ; IF YES, UPDATE PRESENT ~:
POSITION ARRAY
MVI : M,OOH
INX H
: : MVI M,OOH
~20 Ml: EI ;~
UOV A,B
ANA A ; IS B THE LAST MODULE?
JNZ MNEXT ; IF:NO, GO ON TO MEXT MODULE
, ~
` JMP MAIN ; IF YES, START OVER
: ; MANUAL MOVE WAS REQUESTED
MANMV: CALL FOUT ; NOTIFY THE MAIN PROCESSOR
LXI D,OOOOH ; (DE) = NUMBER OF PULSES COUNTED
LXI H,COMM ; ((HL)) : BIT ZERO INDICATES
. RISING PULSE

CALL PART ; C = PARTNER MODULE NUMBER
LDA STATB
CMA

- ~7'7~4~
, ORI OBH ~ ~
STA CONTR ' ANI 40H ~:
LDA LATCH ; WAS NEGATIVE DIRECTION
REQUESTED?
JZ MPOS ~ :
ORI 40H ; IF YES, SET NEGATIVE LATCH
JMP MSIGN
MPOS: ANI OBFH ; IF NO, RESET NEGATIVE LATCH
10 MSIGN: ORI 01H ; SET MANUAL MOVE LATCH
: STA LATCH
CALL CPOUT ; CONNECT PARTNER MODULE (~C) LDA STATE

RRC
RRC
RRC
RRC
ORI 08H ~;
20 ~ STA : CONTB
CALL ~ COUT ; APPROVE REQUEST OF MODULE (#B) MCYCL: CALL PULSE :; WAIT FOR A PULSE `~
CAL SIN ; CHECK STATUS OFF MODULE B
LDA STATE
ANI 01H ; WERE ANY FAULTS DETECTED? `
~: :JNZ MFALT ; IF YES, GO TO MFALT
LDA LATCH

:: :
JNZ MTEST
~ ~ 30 ORI ~ 20H ; PREPARE TEST BYTE
: MTEST: PUSH B
MOV B,A

,. - , . .

7~4~

LDA STATE

JZ MTESl :
CMA

CMP B ; IS MANUAL MOVE STILL
REQUESTED?
MTESl: POP B
JNZ MANFM ; IF NO, COMPLETE THIS MOVE
CALL PULSE ; WAIT FOR A PULSE
CALL SPIN ; CHECK STATUS OF PARTNER ~`~
LDA STATE
ANI 0lH ; WERE ANY FAULTS DETECTED? : -.
JNZ MPFLT ; IF YES, GO TO MPFLT
JMP MCYCL ;. IF NO, CONTINUE THE MOTION
; FAULT WAS DETECTED IN
MODULE #B `
MFALT: LDA LATCH
ANI 0lH ; WAS A MANUAL MOVE IN PROGRESS?
: JZ MAUTO , IF NO, REPORT FAULT TO MAIN
PROCESSOR
CALL BREAK ; IF YES, DISENGAGE MANUAL MOVE
: LDA LATCH :`
ANI OFEH ; RESET M~NUAL MOV.E LATCH
ORI 02H ; SET MANUAL MOVE FAIL LATCH
STA LATCH
CALL UPDAT ; UPDATE POSITION ARRAY
: MAUTO: CALL FOUT ; REPORT FAULT
:: ~ : ::
: ~ JM2 Ml ; CONTINUE ON TO NEXT MODULE
: ; FAULT IN PARTNER DETECTED
MPFLT:~ CALL BREAK ;. DISENGAGE MANUAL MOTION
: ~ M3;: LDA LATCH

ANI OFEH ; RESET MANUAL MOVE LATCH
ORI 02H ; SET MANUAL MOVE FAIL LATCH

~ -18-: ~ - ~ ,. :: '' :

~l 7~ 7 ~, ~

STA L.ATCH
CALL UPDAT ; UPDATE PRESENT POSITION ARRAY
PUSH B
MOV B,C
CALL FOUT ; REPORT PARTNER FAULT
POP B
JMP M1 ; CHECK NEXT MODULE
; COMPLETION OF MANUAL MOVE
MANFN: CALL BREAK ; DISENGAGE MANUAL MOTION
CALL SPIN
LDA STATE
ANI 0lH ; WERE ANY FAULTS DETECTED
IN PARTNER?
JNZ M3 ; IF YES, HANDLE THEM
LDA LATCH ; IF NO, RESET MANUAL MOVE AND
ANI OFC~ ; MANUAL MOVE FAIL LATCHES
STA LATCH
CALL UPDAT ; UPDATE PRESENT POSITION ARRAY
- JMP Ml ; CHECK NEXT MODULE
:
END OF MAIN PROGRAM

Figures 4 through 11 comprise flow charts for the ~Main Program.
::
~ INTERRUPT HANDLING ROUTINES
, ::
The main processor for the APS sends commands to i: : : :
and receives data from the modules by writing to and reading from certain memory locations. This action will cause an interrupt condition to occur in the 8080 processor.
The ~ollowing routines are used to process these ~; interrup$s. The least significant byte of address which the main processor r~ferences is viewed as data by the 8085~
and is used to determine which function the interrupt serves.

L77~

Data i~ passed to and from the main proce~qor through address "DAT~B".
Another interrupt is generated when the pulse generator has finished a motion.
The purpose of this routine is to route the various interrupts to their proper handling routines.
No registers are ever changed in an interrupt routine.
NOTE: The terms "READ" and "WRITE" refer to the pers-pective of the main processor. Thus, a "READ" ;
routine generates data, while a 'IWRITE'' routine receives data.

; READ INTERRUPT HANDLER
; EXECUTED FROM INT 5.5 RINT: PUSH PSW ; SAVE STATUS AND REGISTERS
PUSH B
PUSH D
PUSH H
LDA ALSB
CPI 08H ;~
; VALID READ COMMANDS:
JC RERR
JZ STEST ; 08 = SYSTEMS TEST

JC RERR
JZ RSB ; 0A = READ STATUS BYTE

JC RFMOD ; OB = READ FAULT
MODULE NUMBER
JZ RFB ; 0C = READ FAULT BYTE
CPI OEH
JC RLB ; OD = READ LATCH BYTE

~L~7~11l47 JZ RPLSB ; OE = READ POSITION
(LSB) JZ RPMSB ; OF = READ POSITION
(MSB) JMP RERR ; ANY OTHER COMMAND IS AN ERROR
; WRITE INTERRUPT HANDLER
; EXECUTED FROM INT 6.5 WINT: PUSH PSW ; SAVE STATUS AND REGISTERS `
PUSH B
PUSH D
PUSH H
LDA ALSB
; VALID WRITE COMMANDS:

JC WMOD ; OO = LOAD CURRENT
MODULE NUMBER
JZ WHOME , 01 = SEND ALL MODULES `
~;~ HOME
`~ : CPI ` 03H :
JC WPLSB , 02 = WRITE NEW
: POSITION (LSB) JZ WPMSB ; 03 = WRITE NEW
: POSITION (MSB) : CPI 04H ~-JZ WNUM ; 04 = WRITE # OF
~ : MODULES
:: ` ::~ ~: : ::
::: CPI 06H
JC CUTTR ; . 05 = RAISE OR LOWER
: ` CUTTER
, JZ WCB ; 06 = WRITE CONTROL BYTE
~ : CPI 07H

: ~ JZ EXEQT ; 07 = EXECUTE MOTION
JMP WERR ; ALL OTHERS ARE ERRORS
; PULSE INTERRUPT HANDLER
, EXECUTED FROM INT 7.5 .

- ~

,.77~.~7 PINT: PUSH PSW
LDA LATCH
ANI OF7H ; RESET AUTO MOVE LATCH
STA LATCH
pop PSW
RET

; RETURN FROM INTERRUPT ROUTINE
RFINT: POP H
POP D
POP B ; RESTORE STATUS AND REGISTERS ~.
pop PSW
EI ; ENABLE INTERRUPTS
RET
::
; ERROR HANDLING ROUTINES
: ; READ ERROR: :
RERR: L~A LATCH ~ :
PUSH PSW ; SAVE ORIGINAL LATCH BYTE
ORI ~ 10H ; SET "READ ERROR OCCURRED" LATCH
; JMP ~ IERR
: ; WRITE ERROR:
:: WERR: LDA: : LATCH ~ ~
PUSH PSW ; SAVE ORIGINAL LATCH BYTE
.
; ORI 20H ; SET "WRITE ERROR OCCURRED"
LATCH
~` ; BOTH ERRORS:
IERR: STA LATCH
LDA ~ N
MOV B,A ; CONDITION FOR R/W ERROR (B =
# OF MODULES) : CALL FOUT ; REPORT ERROR TO MAIN P~OCESSOR
pop PSW

. ~`
, ~ ~77~

STA LATCH ; RESTORE LATCH

JMP RFINT ; RETURN FROM INTERRUPT
--_ _ _ _ _ _ Figure 16 is the flow chart for interrupt handling routines pulse handler.
Figure 17 is the flow chart for interrupt handling routines return from interrupt.
Figure 18 is the flow chart for interrupt handling routines error handling.

R E A D R O U T I N E S

~' ROUTINE RSB
This routine allows the main processor to read the ' status of the module whose identification number is stored in location MODNM.
Input Conditions - (MODNM) = MODULE NUMBER

Output Conditions - STATUS-:B~TE-IS SB~T~
MAIN PROCESSOR
Subroutines Called - SIN

:::
RSB: LDA STATB
PUSH PSW ; PRESERVE OLD STATUS WORD
LDA MODNM

MOV B,A ; (B~ = REQUIRED MODULE NUMBER
CALL SIN ; GET STATUS OF MODULE B
LDA STATB

STA DATAB ; OUTPUT STATUS BYTE TO MAIN
PROCESSOR
POP PSW
STA STATB , RESTORE STATUS BYTE
JMP RFINT

X Figure 19 i~ the flow chart for routine "RSB".

:

" ~7~91L7 ROUTINE RFMOD
This routine allows the main proces~or to read the module number which caused the fault. Note that if this number is equal to the number modules, then the fault was caused by a read/write error.
Input Condition~ - (B) = MODULE # CAUSING FAULT

Output Conditions - MODULE # SENT TO MAIN
PROCESSOR
Subroutines Called - NONE

RFMOD: MOV A,B

STA DATAB ; OUTPUT MODULE NU~ER TO MAIN
PROCESSOR
JMP RFINT

Figure 20 is the flow chart for routine "RFMOD".

ROUTINE RFB
This routine allows the main processor to read the status byte of the module causing the fault. Note that on a read/write error, the byte read-has no significance, but must be read to recet a latch.
Input Conditions - (STATB) = FAULT BYTE

Output Conditions - FAULT BYTE SENT TO MAIN
PROCESSOR
FAULT ACKNOWLEDGEMENT LATCH
(BIT #2 OF "LATCH") IS RESET
Subroutines Called - NONE
~::
RFB: LDA STATB

STA DATAB ; OUTPUT FAULT BYTE

LDA LATCH

ANI OFBH ; RESET FAULT ACKNOWLEDGEMENT
LATCH

STA LATCH

JMP RFINT

, 177~7 Figure 21 comprises the flow chart for routine "RFB".

ROUTINE RLB

This routine allows the main processor to read the byte at location "LATCH".

Input Conditions - NONE

Output Conditions - LATCH BYTE IS SENT TO ~IN
PROCESSOR

Subroutines Called ~ NONE
' RLB: LDA LATCH
STA DATAB ; OUTPUT LATCH BYTE
JMP RFINT ~`

Figure 22 is the flow chart for routine "RLB".

: ROUTINE5 RPMSB AND RPLSB

These two routines allow the main processor to read the present position of the module whose identification number is in location MODNM. Distances are measured in ~ units of pulses, where one pulse = .005 inches. The position ; ~ ~ is~stored in the array pres in two consecutive memory loca- ~ -tions. The ~irst is the least significant byte, and the second is the most significant byte. RPLSB sends the first .
one to the main processor, and RPMSB sends the second.

Input Conditions - POSITION IS STORED IN ARRAY
PRES (MODNM) = MODULE NUMBER

Output Conditions - APPROPRIATE BYTE SENT TO MAIN
PROCESSOR

Subroutines Called - PPADD

X

~ ~7~L47 RPMSB: LDA MODNM
MOV B,A ; (B) = CURRENT MODULE NUMBER
CALL PPADD

INX H ; ((HL)) = PRESENT POSITION
(MOST SIGNIFICANT BYTE) :
JMP RPOS

RPLSB: LDA MODNM
MOV B,A ; (B) = CURRENT MODULE NUMBER

CALL PPADD ; (~HL)) = PRESENT POSITION
(LEAST SIGNIFICANT BYTE) .

RPOS: MOV A,M
STA DATAB ; OUTPUT APPROPRIATE BYTE
JMP RFINT

Figure 23 is the flow chart for routines RPMSB ;
and RPLSB.

W R I T E R O U T I N E S

: ROUTINE WNUM
: :: This routine alIows the main processor to enter the~total number of modules which are on line. This number : ~is stored~in location N. Note that this routine must be executed before the monitor program will begin checking status.
: Input Conditions - NONE

: Output Conditions - (N) = NUMBER OF MODULES ON
LINE
: Subroutines Called - NONE
WNUM: LDA DATAB ; INPUT NUMBER OF MODULES
~::
STA N

JMP RFINT

Figure 24 is the routine for "WNUM".

' - ~L7'71~
ROUTINE WMOD
This routine allows the main processor to enter the identification number of a module. This number will be used in subsequent read/write operations. The data will be stored in location N.
Input Conditions - NONE
Output Conditions - (N) = MODULE NUMBER
Subroutines Called - NONE

WMOD: LDA DATAB ; INPUT MODULE NUMBER
STA MODNM
JMP RFINT

Figure 25 is the flow chart for routine "WMOD".

ROUTINES WPLSB AND WPMSB
These routines allow the main processor to enter the new position of the module whose idsntification number is stored in location MODNM. m is position is stored in a future position array located at FUTR. Like the present position arrav, numbers are stored in FUTR in two bytes:
first the least significant byte, then the most significant byte. ~WPLSB stores the least significant byte, and WPMSB ;
stores the most significant byte.
~ WPMSB also a~fects an array known as the Auto Move Request array. Each bit in this array corresponds to a different module pair. WPMSB will set the appropriate bit, which will eventually be used to decide if the module pair should be moved.
Input Conditions - ~MODNM) = MODULE NUMBER

Output Conditions - FUTURE POSITION STORED IN
ARRAY FUTR BIT IN AMR ARRAY
SET (AFTER WPMSB) Subroutines Called - AMRAD
FPADD

~.
, 7~7 WPLSB: LDA MODNM
MOV B,A ; ~B) = CURRENT MODULE
CALL FPADD ; ((HL)) = FUTURE POSITION (LSB) LDA DATAB ; GET BYTE FROM MAIN PROCESSOR
AND ::
MOV M,A i STORE IT IN MEMORY
JMP RFINT ~-WPMSB: LDA MODNM
MOV B,A ; (B) = CURRENT MODULE
CALL FPADD
INX H ; ((HL)) = MSB OF FUTURE
:POSITION
LDA DATAB ; GET BYTE FROM MAIN PROCESSOR
AND
: ` MOV M,A ; STORE IT IN MEMORY
; CALL AMRAD
ORA M
MOV M,A ; SET BIT IN AUTO MOVE REQUESTED
ARRAY
:
JMP RFINT

Figures 26 and 27 are the flow charts for routines 'WPLSB" and "WPMSB".

ROUTINE CUTTR~ :
This routine allows the main processor to raise ~:: : : or lower the cutter of the module (and its partner~ whose ;~ identlfication number is located in location MODNM. To raise the CUTTR, the main processor should write "08H" into ::: : memory. To lower:the cutter the main processor should : write "OOH" into memory.
Input Conditions - (MODNM) = MODULE NUMBER
Output Conditions - (CONTB) IS CHANGED CUTTER
IS MOVED

.

~771~'7 Subroutines Called - COUT
CPOUT
PART

CUTTR: LDA DATAB
ANI OBH ; (DATAB) - 0.8H FOR RAISING
CUTTER ~ND
ORI 06H ; 00H FOR LOWERING CUTTER
STA CONTB
LDA MODNM
MOV B,A , (B) = CURRENT MODULE `
CALL PART ; (C) = PARTNER MODULE
CALL COUT ; RAISE OR LOWER CURRENT MODULE
CALL CPOUT ; RAISE OR LOWER PARTNER
JMP ~FINT

Figure 28 is the flow chart for routine "CUTTR".
~ , ROUTINE WCB
This routine allows the main processor to write a control byte directly to the module whose identification number is stored in Iocation MODNM.
Input Conditions - (MODNM) = MODULE NUMBER
Output Conditions - ~CONTB) = DATA FROM MAIN
PROCESSOR
Subroutines Called - COUT

WCB: LDA MODNM
MOV B,A ; (L) = CURRENT MODULE
LDA DATAB ; (DATAB) = DESIRED CONTROL BYTE
STA : CONTB
CALL COUT ; OUTPUT COMMAND
: JMP RFINT

Figure 29 is the flow chart for routine "WCB".

~ ~ , -- ~17~ 14~7 ROUTINE WHOME
This routine allows the m~in processor to send all modules to the home po~ition. Thi6 is accompli~hed by first moving all modules to the right 62 inches. Since the modules cannot (except by inertial effects) move past their home positions, they will all stop when they reach that point.
A correction is made for any overshooting due to momentum by backing all modules out 1/2 inch and moving them back slowly to the home position.
This routine also initializes the present position array, and interrupts the main processor.
Input Conditions - (N~ = NUMBER OF MODU~ES
Output Conditions - (CONTB) = DEH
ARRAY PRES = 0 UP TO NTH
ELEMENT
. MAIN PROCESSOR INTERRUPTED
Subroutines Called - ENDAM
MASMV
UNITY

WHOME: LDA DATAB ; COMPLETE "READ" OPERATION
LDA N
ANI 0lH
LDA N
JZ Wl ; DOES LAST MODULE HAVE AN
ACTIVE PARTNER
INR A ; IF NO, ACTIVATE PARTNER
W1: STA NPAIR
MVl A,OEH ; MASK INTERRUPTS 5.5 AND 6.5 MV1 A,4EH
CALL UNITY
LXI H,3070H
C~LL MASMV ; MOVE ALL MODULES 62 INCHES
NEGATIVE (HARD ZERO) MVI A,ZEH

14~

CALL UNITY
LXI H,0064H
CALL MASMV ; BACK ALL MODULES OFF 1/2 INCHES

CALL UNITY
LXI H,0050H
CALL MASMV ; MOVE ALL MODULES .4 INCHES
NEGATIVE
LXI H,00lEH ~.
CALL MASMV ; MOVE ALL MODULES BACK HOME
MVl A,OEH ; (SOFT ZERO) CALL UNITY
LDA NPAIR
LXI H,PRES
W2: DCR A
MVI M,00H
INX H

. MVI A,o8H
~: : DB 30H ; UNMASK ALL INTERRUP~S :
CALL ENDAM ; INFORM MAIN PROCESSOR THAT
MOVE IS DONE
~ .
~ JMP RFINT

~ .
~ ~ .
Figures~30, 31 and 32 are the flow charts for : ~routine "WHOME".
: :
ROUTINE EXEQT

This routine allows the main processor to actually : .
execute any moves which were entered through a "write posi-tion'l command. This is accomplished by first checking to see which modules must be moved, and connecting these to the pulse generator so that they will move in the desired .~

~-: . , :
. : : - :. - ' 7~47 direction. The future po~ition array i~ replaced with the distances which the modules have to move, with zero being en~
tered ~or those modules not m~ving. All modules connected are -then moved the smallest of all these distances, and the distance moved is ~ubtracted from all the remaining distances.
Those modules which have reached their goal are then dis-connected and the procedure is repeated until all modul~s have reached their goals.
This routine also updates the present position array, and interrupts the main processor when done.
Input Conditions - ALL ARRAYS PRESET FOR MOVE
(N) = NUMBER OF MODULES

Output Conditions - MOTION COMPLETED
ARRAYS FUTR AND AUTO MOVE ARE
CLEARED
ARRAY PRES IS UPDATED
(SMALL) = "FFFFH"
(NUMON) = "OOH"
LOSS,NPAIR,CONTB ARE MODIFIED
MAIN PROCESSOR IS INTERRUPTED

Subroutines Called - AMRAD
COUT
CPOUT
ENDAM
FPADD
LEAST
PART
PPADD
TWOSC

EXE~T: LDA DATAB ; COMPLETE "WRITE" OPERATION
MVI A,08H
DB 30H , MASK INTERRUPTS 5.5 AND 6.5 MVI A,OOH
STA NUMON ; NUMON = NUMBER OF MODULES
ACTUALLY MOVING

LXI H,0FFFFH
SHLD SMALL ; (SMALL) = SMALLEST DISTANCE
ANY MODULE MUST MOVE
LDA N

LDA N ; (N)= NUMBER OF MODULES ON
LINE

17'7:147 :. `
JZ E0 ; (IF LAST MODULE'S PARTNER
IS NOT ON LINE, INR A ; INCLUDE IT.IN MOTION) E0: STA NPAIR
MOV B,A .
El: DcR B
~CR B -CALL AMRAD
ANA H ; IS MODULE B TO BE MOVED?
JZ NOMOV ; IF NO, SKIP IT :~
CALL PPADD
MOV E,M
INX H -MOV D, M
PUSH D
. CALL FpADD
MOV E,M
INX H ; (DE~ = FUTURE POSITION OF
MODULE B
:
MOV D,M
CALL PPADD
MOV M,E ~ ;~
: INX H ; UPDATE PRESENT POSITION
: : ARRAY WITH
MOV ~ M,D ; FUTURE POSITION
POP H ; (HL) = PRESENT POSITION OF ~:F
: : MODULE B
MOV A,H
CMP D
JN2 E2 ; IS PRESENT POSITION =
: FUTURE POSITION?
; : MOV A,L
:
: CMP : E
JZ NOMOV ; IF YES, SKIP THIS MODULE

:
~ X -33-: :. .
.

-`; 1.1~7'7~7 `~

E2: CALL TWOSC
DAD D ; SUBTRACT FUT POS FROM PRES POS
XCHG
JC EXNEG ; IS RESULT POSITIVE?
CALL PPADD
MOV A,M
ANA A
JNZ ~ EXPOS ; OR WAS DESTINATION HOME
POSITION~
INX H
MOV A,M
ANA A
: JZ EXNEG
EXPOS: CALL TWOSC ; IF NO, TAKE ABSOLUTE VALUE
OF DIFFERENCE AND
MVI A,2EH ; CONNECT IN POSITIVE DIRECTION

EXNEG: MVI A4EH ; IF YES, CONNECT IN NEGATIVE
: : :~ DIRECTION
E3: ~ STA CONTB ; (RAISE CUTTER IN EITHER CASE) CALL FPADD ; STORE. DISTANCE t=(DE)) IN
MOV M,E ; FUTURE POSITION ARRAY
~ ~ , :: : INX H
MOV~ M,D
LDA N~MON ~ :
: : INR ~ A ~ : ; INCREMENT # OF MODULES MOVING
STA NUMON
: ~ CALL LEAST ; IF (DE)~ (LEAST), REPLACE LE~ST
: WITH (DE) - NOMOV: MVI A,0OH
; ~ CALL FPADD

MOV M,A
INX H ; SET DISTANCE = O
MOV M,A
X

- ~L7~47 ~.
MVI A,0EH ; DISCONNECT MODULES AND
RIASE CUTTERS
STA CONTB
E4: CALL PART ; (C~ = B'S PARTNER
CALL COUT ; EXECUTE COMMAND TO MODULE
CALL CPOUT ; EXECUTE COMMAND TO PARTNER
MOV A,B
ANA A ; HAVE ALL MODULES BEEN CHECKED?
JNZ . El ; IF NO, CHECK NEXT MODULE
MVI A,OEH
STA CONTB
E5: LDA NUMON
ANA A ; ARE ANY MODULES CONNECTED? ".
JZ EXIT ; IF NO, EXIT ROUTINE ' LDA LATCH ~ ~`
ORI 08H ; IF YES, SET AUTO MOTION LATCH
STA LATCH
LHLD SMALL , SMALL IS DISTANCE TO BE MOVED
EI
~; SHLD SWTCH ; INITIATE MOTION
XCHG
: CALL : TWOSC
XCHG
: SHLD : LOSS ; (LOSS) = -(DISTANCE MOVED) LXI H,OFFFFH ,:
: ~ ~ SHLD SMALL , SMALL INITIALIZED FOR NEXT
: MOTION
: ::
LDA NPAIR :
MOV B,A ; BEGIN CALCULATIONS FOR NEXT
MOTION
E6: DCR : B ~ ~
:: : DC~R B ~ -: CALL FPADD

MOV E,M

X

.: . . ~ . ,. :

7~47 , INX H ; (DE) = OLD DISTANCE MODULE
HAD TO MOVE
MOV D,M
MOV A,D
ANA A -~
JNZ E7 ; WAS THIS DISTANCE ZERO?
MOV A,E
ANA A
JZ ESKIP ; IF YES, SKIP THIS MODULE : -LHLD LOSS
DAD D ; OTHERWISE, SUBTRACT DISTANCE
MOVED
XCHG
CALL PPADD ; STORE NEW DISTANCE IN FP ARRAY
MOVE M,E
INX H
MOV M,D
MOV A,D
ANA A ; IS NEW DISTANCE ZERO?
JNZ EB
MO~ A,E
ANA A
JNZ EB :~
LDA NUMON ; IF YES, DECREMENT THE
NUMBER CONNECTED
DCR : A
STA ~ NUMON
:, JMP ESKIP
E8: CALL LEAST ; IF NO, DETERMINE IF DISTANCE
IS THE SMALLEST
ESKIP: MOV A,B
: ~ ~ ANA A ; IS THIS THE LAST MODULE?

JNZ E6 ; IF NO, GO TO NEXT ONE
EW~IT: LDA LATCH

~< :

... .
:

77~7 ANI 08H ; WAIT UNTIL MOTION HA5 STOPPED
JNZ EWAIT
LDA NPAIR : ~:
MOV B,A
E9: DCR B
DCR B
CALL FPADD `
MOV A,M
ANA A
JNZ E10 ; IS REM~INING DISTANCE ZERO?
INX H - :
MOV A,M ~:
ANA A

~ CALL PART
: CALL COUT ; IF YES, DISCONNECT MODULE
~ ~ AND PARTNER
~:' : CALL CPOUT
~: .
E10:: MOV A,B
: ANA : A ; IS THIS THE LAST MODULE?
:
JNZ E9 ; IF NO GO ON TO NEXT MODULE
JMP E5 ; IF YES, BEGIN NEXT MOTION
:: , ; EXIT: MVI : B,l~H
; LXI H,AUTMV
: MVI A,0~H
~: :
: ERASE: MOV M,A ; CLEAR AUTO MOVE ARR~Y
: :DCR B ::
: ~ : JNZ ERASE
; ~ MVI A,08H
~ DB 30H ; UNMASK ~LL INTERRUPTS

: CALL ENDAM ; INFORM MAIN PROCESSOR THAT
MOVE IS DONE .
JMP RFINT

XEND OF INTERRUPT_HANDLING ROUTINES
-37- .

,, - , ,: ', " ~ ~
; . , , ~ , . . :

- 117~14~ , S U B R O U T I N E S

SUBROUTINE PART
This subroutine computes the identi.fication number of the.partner of the module whose identification number is stored in register B. The result is stored in register C.
Module pairs are as follows: 0 and 1 are paxtners, 2 and 3 are partners, 4 and 5 are partners, etc.
Input Conditions - (B) = MODULE NUMBER
Output Conditions - (C) = PARTNER MODULE NUMBER
Subroutines Called - NONE
Registers Affected - C

PART: PUSH PSW
MOV A,B
: RAR ; COMPLEMENT ZERO BIT OF
MODULE NUMBER
CMC ; TO GET PARTNER'S NUMBER :
RAL
MOV C,A ; STORE IN C
' poP PSW
RET
~ .
Figure 40 is the flow char~ for subroutine "PART".

SUBROUTINE BREAK
This subroutine disengages the manual motion of the modules whose identification numbers are in registers B and C. Normally, C should be B's partner.
Input Conditions - (B) = MODULE NUMBER
. (C) = PARTNER MODULE NUMBER
Output Conditions - (CONTB) = "OE~"
Subroutines Called - COUT
CPOUT

Registers Affected - NONE
X

7'7~9~7 "

BRE~K: PUSH PSW :;
MVI A,OEH
STA CONTB
CALL COUT ; DISENGAGE MODULE #B
CALL CPOUT ; DISENGAGE PARTNER
POP PSW ~;
RET
'~
Figure 41 is the flow char~ for subroutine "BREAK".
, ~
SUBROUTINES PPADD AND FPADD ~
. -.
These subroutines calculate the addresses in memory ~
which hold the present (PPADD) and future (FPADD) positions ~ :
of the module whose identification number is in register B.
The result is stored in register pair HL.
Input Conditions - (B) = MODULE NUMBER
:: : ; Output Conditions - ((HL)) = POSITION (LSB) ((HL)+l~ = POSITION (MSB) ~-: Subroutines Called - NONE
Reglsters Affected~- H,L

PPADD: LXI :: H,PRES ; PRES = BASE ADDRESS OF .
: PRESENT POSITION ARRAY
: ; JMP ~ OFFST ~ ~;
;FPADD:~ :LXI: ~ H,FUTR ; FUTR = BASE ADDRESS OF
: FUTURE POSITION ARRAY
OF~FST~: PUSH :: ~D
:~ : PUSH PSW :
:
~: MOV ~A,B ; (B) = MODULE NUMBER :
ANI 0FEH ; RESET BIT 0 W V E,A
MVI D,00H ; (DE) = OFFSET TO DESIRED
: : ADDRESS
: DAD D ; (HL) = DESIRED ADDRESS

:':
POP PSW

l4~

POP D
RET

Figure 42 is the flow chart for subroutin~ "PPADD"
and "FPADD".

SUBROUTINE SPIN
This subroutine inputs one byte of status informa-tion from the module whose identification number is in register C. (C is normally the partner to B.) This byte will be stored in location STATB.
Input Conditions - (C) = PARTNER MODULE NUMBER
,, Output Conditions - (STATB) = STATUS BYTE READ

Subroutines Called - SIN

Registers Affected - NONE

SPIN: PUSH B

MOV B,C

CALL SIN

POP B

RET

Figure 43 is the flow chart for subroutine "SPINI'.
.
: ~ SUBROUTINE CPOUT

This subroutine outputs one byte of control information to the module whose identification number is stored in register C (C is normally the partner to register : ~ B). The control byte is taken from location CONTB.

Input Conditions - (C) = PARTNER MODULE NUMBER
(CONTB) = CONTROL BYTE
Output Conditions - NONE

Subroutines Called - COUT

X Registers Afected - NONE

:' 77~

CPOUT: PUSH B
MOV B,C
CALL COUT
POP B
RET
:, Figure 44 is the flow chart for subroutine "CPOUT".

SUBROUTINE UPDAT

This subroutine updates the present position array after a manual move has taken place. The number of pulses in the move is stored in register pair DE. The identifica-tion number of the module which moved is stored in register B.
Input Conditions - (DE) = DISTANCE MOVED
(B) - MODULE NUMBER
NEGATIVE MOTION LATCH IS SET IF ~:
MOTION WAS NEGATIVE

Output Conditions - PRES ARRAY IS UPDATED

~ : Subroutines Called - PPADD ~
:: ; TWOSC : ~ -':
Registers Affected - NONE : ~
~ .
:::
UPDAT: PUSH D
PUSH H
: , : PUSH : PSW
:::
CALL PPADD

PUSH ~: H
:
PUSH ~ D ..
P ~ : MOV ~ E,M
INX H . ::
MOV~ : D,M
XCHG ; HL NOW HOLDS THE ORIGINAL
POSITION
POP D ; DE NOW HOLDS THE DISTANCE THE
MODULES MOVED
LDA LATCH
X

~- : :
- ; . : . . :.' , ~ - ., .- ~
,: .
': ~ ' : ' ~ . ` :

t7~L4~

ANI 40H ; WAS THE MOTION NEGATIVE?

JZ Ul CALL TWOSC ; tDE) = TWO'S COMPLEMENT OF (DE) Ul: ~AD D ; ADD DISTANCE MOVED TO OLD
POSITION TO GET

XCHG ; NEW POSITION

POP H

MOV M,E

INX ~ ; STORE NEW POSITION IN ARRAY

MOV M,D

POP PSW

POP H

POP D

:
Figure 45 is the flow chart for subroutine "UPDAT".

SUBROUTINE FOUT
::: ~ ` :
This subroutine notifies the main processor that elther a fault occurredora manual motion was requested.
The routine interrupts the main processor and then delays for 5~msec. ,When the main processor is interrupted, it should read the fault module and then read the fault byte.
Reading the fauit byte resets a latch which allows the 8085 to step out of the delay loop.
If the fault was a read/write error, then the data transfer is completed while the interrupt is in progress.
Input Conditions - NONE
Output Conditions - MAIN PROCESSOR INTERRUPTED
Subroutlnes Called - NONE
Registers Affected - NONE

:: :

FOUT: PUSH D :~
PUSH PSW
LDA LATCH

STA LATCH ; SET FAULT ACKNOWLEDGEMENT :
LATCH :~`
MVI D,ODCH ; SET LOOP COUNTER FOR 5 : ;
MSEC DELAY :
: MVI A,80H
STA COMM ; INTERRUPT MAIN PROCESSOR ;~
LDA LATCH
ANI 30H ; WAS FAULT A READ/WRITE ERROR?
~ JZ F2 ~ -: ANI 20H ; IF YES, THEN COMPLETE THE
READ OR WRITE
JNZ Fl STA DATAB
~ : JMP F2 :
: Fl: LDA DATAB ~`~
~F2: NOP ~` -NOP -`
~ ~ , MVI A,00H

STA COMM ; TU~N OFF INTERRUPT
FLOOP~ LDA ~ LATCH ~ ;
ANI 04H ; HAS FAULT BEEN ACKNOWLEDGED?
: ~ JZ : FEND ; IF YES, EXIT LOOP

: ~ : ~ : ; -- -- -- -- -- -- -- _ _ _ _ ~.
THL ; ) ;~ .
:~ XTHL ~ ; D E L A Y ) : XTHL ; ) : XTHL

~
DCR D
JNZ FLOOP ; CONTINUE THROUGH LOOP

.

- : : .- : , FEND: DI
POP PSW
pop D `i RET

Figures 46 and 47 are the flow charts for 6ub-routine "FOUT".

SUBROUTINE TWOSC ~ ;
This subroutine calculates the two's complementof the number stored in register pair DE. The result is then stored in DE.
Input Conditions - (DE) = NUMBER OF INTEREST
Output Conditions - (DE~ = 2's COMPLEMENT OF NUMBER
Subroutines Called - NONE
: Registers Affected - D,E

~ TWOSC: PUSH PSW
:~ MOV A,D
CMA ; COMPLEMENT WITH HIGH ORDER BYTE
MOV D,A
MOV A,E ~.
: CMA ; COMPLEMENT LOW ORDER BYTE
: ~ MOV E,A
: INX D ; ADD 1 POP : PSW
~:
::: RET

Figure 48 is the flow chart for subroutine "TWOSC".
;

SUBROUTINE PULSE
This subroutine is used in a manual move to wait : for a pulse and to keep track of *he position of the module.

lI7'7~4~
, ~ ,. , The routine has a time-out feature which returns to the ;
calling routine if no pulse has been detected in 200 msec.
Input Conditions - (HL) = COMM
(DE) = PREVIOUS PULSE COUNT
Output Conditions (DE) = NEW PULSE COUNT
Subroutines Called - NONE
Registers Affected - A,D,E

~ .
PULSE: PUSH B ; PRESERVE STATUS
MVI B,80H
MVI C,00H ; SET REGISTERS FOR 200 MSEC
DELAY
PULSl: MOV A,M
ANI 01H ; IS A RISING PULSE OBSERVED?
JNZ PULS2 ; IF YES, EXIT
OCR C
; ~, ; JNZ PULSl OCR B ; HAS 200 MSEC ELAPSED?
; JNZ PULSl ; IF NO, KEEP CHECKING
POP B
RET ~ ; IF YES, RETURN
PULS2: POP B
:
INX D ; INCREMENT PULSE COUNTER
AND RETURN
RET

Figure 49 is the flow chart for subroutine "PULSE".

: ~ :
SUBROUTINE LEAST
This subroutine compares the 2 byte number stored in register pair DE with the number stored at location SMALL
and SMALL+l. The smaller of the two numbers is stored in .
SMALL and SMALL+l.
Input Conditions - (DE) = NEW NUMBER
(SMALL) = OLD NUMBER (LSB) X ~SMALL~l) = OLD NUMBER (MSB) :

l7'7~7 Output Conditions - (SMALL) = SMALLEST NUMBER (LSB) (SMALL+l) = SMALLEST NUMBER (MSE) Subroutines Called ~ NONE

Registers Affected - NONE
:

LEAST: PUSH PSW
LDA Sr~LL+OO0lH
CMP D ; COMPARE MOST SIGNIFICANT BYTES
JC LEXIT
JNZ Ll LDA SMALL :
CMP E ; IF NECESSARY, COMPARE LEAST
SIGNIFICANT BYTES . :~
JC LEXIT
JZ LEXIT ~ :
: Ll: XCHG
SHLD SMALL ; IF (DE) < (SMALL), REPLACE
XCHG
LEXIT: POP PS~
RET

Figure 50 is the flow chaFt for subroutine "LEAST".

; SUBROUTINE AMRAD
This subroutine finds the address and bit indicating ~;
whether a particular module has been programmed to move. Thè
auto move requested array (located at AUTMV) is a 16 byte array where each bit is reserved for a certain regist r pair.
: That bit is a 1 if the module is to be moved This routine stores the address in register pair HL : ``
~and sets the appropriate bit (as well as resetting all other bits) in the accumulator.
EXAMPLES:

. ~ .
. ~ ., , 7'7:1~7 MODULE PAIR (HL) ~A) 0,1 AUTMV 0000 0001 8,9 AUTMV 0001 0000 ~
2A,2B AUTMV+0002 0010 0000 ~:
Input Conditions - (B) = MODULE NUMBER
Output Co~ditions - (HL) = ADDRESS
(A3 = 1 IN APPROPRIATE BIT
Subroutines Called - NONE
Registers ~ffected - A, H, L
:`~
AMRAD: PUSH D
MOV A,B
RRC
RRC
~ .
RRC
RRC -~
,, MOV E,A ~:
MVI D,00H
: : : : ~
: LXI H,AUTMV ; AUTMV IS BASE ADDRESS OF AUTO
MOVE REQUESTED ARR~Y :~
DAD D ; (HL3 = ADDRESS
MOV A,B
RRC
: ANI 07H `
MOV ~ D,A
: INR D
::: : :

ALOOP: RLC : ; A HAS A 1 IN THE APPROPRIATE
BIT
: DCR D ~ -JNZ ALOOP

:
POP D
: RET
Figure 51 is the flow chart for "AMRAD".

~l~7t7~L47 SUBROUTINE UNITY

This subroutine outputs one byte of control infoxmation to every module on line. The control byte i~

taken from the accumulator.

Input Conditions - (N~ = NUMBER OF MODULES
(A) = CONTROL BYTE

Output Conditions - (CONT~) = CONTROL BYTE
(NPAIR) IS MODIFIED

Subroutines Called - COUT

Registers Changed - NO~E

UNITY: PUSH PSW

PUSH B

STA CONTB

LDA NPAIR

MOV B,A

: UNl: DCR B

C~LL COUT ; OUTPUT BYTE TO MODULE B

..
: JNZ UNl ; GO ON TO NEXT MODULE

:~ POP B
POP PSW
: ; RET
Figure 52 is the flow chart for subroutine "UNITY".

SUBROUTINE MASMV
~ This routine requests the pulse generator to send out the number of pulses stored in register pair HL. The routine then waits until the motion is completed before it returns to the calling routine.
Input Conditions - (HL) = NUMBER OF PULSES DESIRED
: Output Conditions - NONE
Subroutines Called - NONE
Registers Af~ected - NONE

~ , ,: . .

~771~L7 ~

MASV: PUSH PSW
LDA LATCH
ORI 08H ; SET AUTO MOVE LATCH
STA LATCH
EI
SHLD SWTCH ; INITIATE MOTION
MASWT: LDA LATCH
ANI 08H ; WAIT UNTIL MOTION IS
COMPLETED s JNZ MASWT
POP PSW '' RET
Figure 53 is the flow chart for subroutine "MAS MV".

SUBROUTINE ENDAM
This subroutine interrupts the main processor and indicates that an auto motion has been completed. This is accomplished by setting bit #4 in "STATB" and calling FOUT.
Input~Conditions - NONE
~; Output Conditions - MAIN PROCESSOR IS INTERRUPTED
; Subroutines Called - FOUT
Registers Affected - NONE

. .
ENDAM: PUSH ~ PSW
LDA STATB
PUSH PSW ; SAVE OLD STATUS BYTE
MVI A,lOH
STA STATB ; STATB INDICATES END OF AUTO
MOVE
CA~LL FOUT ; INTERRUPT MAIN PROCESSOR
POP PSW
STA STATB ; RESTORE OLD STATUS BYTE
POP PSW
RET
X Figure 54 is the flow chart for subroutine "ENDAM".

' SUBROUTINE COUT
This subroutine ou puts one byte of control information to the module who~e identification number i~
~tored in register B. The control byte must be located in location CONTB.
Execution Time - 2315 STATES
Input Conditions - (RBG B) = MODULE NUMBER
(CONTB) = CONTROL BYTE
Output Conditions - INTERRUPTS DISABLED
Subroutines Called - NONE
Registers Affected - NONE

; SAVE STATUS
COUT: DI
PUSH H
PUSH B ``
PUSH D
PUSH PSW
; ENABLE BUS DRIVERS
LXI H,COMM ; BUS ADDRESS
: MVI E,2AH
MOV M,E
; SET UP REGISTERS FOR PASS 1 AND 2 : STC ; SET CARRY BIT
~ MOV A,B
: ~I C,02H ; PASS COUNTER
MVI B,14H ; SUBTRACT DATA FOR FALLING EDGE
MVI D,01H ; BIT COUNTER
: MVI E,3FH ; DATA FOR RISING EDGE
JMP PASBC
; RESET REGISTERS FOR PASS 1 AND 0 PASIC: MVI B,04H ; SUBTRACT DATA FOR FALLING EDGE
MVI D,08H ; BIT COUNTER

JMP PASAC

, ~7';J~

; RESET REGISTER FOR PASS 0 PASOC MVI D,0EH ; BIT COUNT~R
LDA CONTB ; CONTROL BYTE
NOP
NOP
; OUTPUT D BITS FOR PASS C
PASAC: MVI E,2FH ~ :
PASBC: RAR
JC SKIPC
DCR E
SKIPC: MOV M,E ; OUTPUT RISING EDGE OF CLOCK
PUSH PSW
MOV A,E
SUB B
MOV E,A :
pop PSW
MOV M,E ; OUTPUT FALLING EDGE OF CLOCK
DCR D
JZ PAS?C
XTHL ; : ~`
XTHL ; THIS IS A 36 STATE DELAY
: NOP
JMP PASAC
; DETERMINE IF NEXT PASS IS PASS ZERO
PAS?C: DCR C
: JZ PASOC
; DETERMINE IF NEXT PASS IS PASS 1 OR FINISHED
Jp PASlC `
; DISABLE BUS DRIVERS
MVI E,OOH
MOV M,E
; RESTORE STATUS
POP PSW

177~l7 POP D
POP B
POP H
; RETURN TO CALLING SUBROUTINE
RET

SUBROUTINE SIN
This subroutine inputs one byte of status :
information from the module whose identification number is stored in register B. This status byte will be located in location STATB.
Execution Time - 2329 STATES
Input Condltions - (REG B) = MODULE NUMBER
Output Conditions - (STATB)= STATUS BYTE READ
INTERRUPTS DISABLED
Subroutines Called - NONE
Registers Affected - NONE

SAVE STATUS :
SIN: : DI
~ PUSH H
: ~ PUSH B
PUSH D
PUSH PSW
; ENABLE:BUS DRIVERS
LXI H,COMM ; BUS ADDRESS
: . MVI E,2AH
MOV M,E
: ; SET UP~REGISTERS FOR PASS 2 AND 1 : XRA A ; CLEAR CARRY BIT
MOV A,B
MVI C,02H ; PASS COUNTER

MVI B,14H ; SUBTRACT DATA FROM FALLING EDGE

- , . ~: , ;1 ~7~47 , ~

MVI D,01H ; BIT COUNTER
MVI E,3FH ; DATA FOR RISING EDGE
JMP PASBS
; RESET REGISTERS FOR PASS 1 AND 0 PASlS: MVI B,04H ; SUBTRACT DATA FOR FALLING EDGE
MVI D,08H ; BIT COUNTER -; OUTPUT D BITS FOR PASS C
PASAS: MVI E,2FH
PAS~S: RAR
JC SKIPS
DCR E
SKIPS: MOV M,E ; OUTPUT RISING EDGE OF CLOCK
PUSH PSW
MOV A,E
SUB B :
MOV E,A
POP PSW
MOV M,E ; OUTPUT FALLING EDGE OF CLOCK
DCR D
JZ PAS?S
XTHL
XTHL ; THIS IS A 36 STATE DELAY
NOP
JMP PASAS
; DELAY THEN DETERMINE IF NEXT PASS IS PASS 1 OR PASS 0 PAS?S: NOP
NOP
NOP
NOP
DCR C
JNZ PASlS
; RESET REGISTERS FOR PASS 0 MVI D,08H ; BIT COUNTER

7'~
, ~

MVI C,00H
; INPUT D BITS FOR PASS 0 PASOS: NOP ; TI~lING DELAY
NOP
NOP
NOP
MVI E,2CH
MOV M,E ; OUTPUT RISING EDGE OF CLOCK
PUSH PSW
MOV A,E
SUB B
MOV E,A
POP PSW
MOV M,E ; OUTPUT FALLING EDGE OF CLOCK
MOV A,M ; GET INPUT BYTE

ORA C ; READ A BIT
; ~ DCR D
: JZ DONES
RRC ; POSITION BITS
MOV : C,A ; SAVE STATUS BYTE THUS FAR
NOP ; TIMING DELAY
:NOP
~: : JMP ~PAS0S
`~; DISABLE BUS DRIVERS -; : DONES: MVI E,0OH
; MOV M,E ~:
; STORE THE STATUS BYTE READ AT STATB
~ : ~ STA STATB
: ~ ; RESTORE~STATUS
: POP PSW
:: POP D
POP B
POP H

- ~ . . ,~ . ~-,: `

~'7~

; RETURN TO CALLING SUBROUTINE
RET
___________ END OF SUBROUTINES
______________ In operation, when the operator desires to move the top and bottom slitter stations, he supplies this infor-mation into the keyboard 52 of the operator console 80. The main processor 53 transmits commands to the control proces sor which executes them under the control of the preceding program, establishing the necessary communications with each of the top and bottom slitter stations. These stations then control their associated blade or band to the proper posi-tion.
Although the invention has been described with respect to preferred embodiments, it is not to be so limited as changes and modifications can be made which are within th~ fyll intcnded scope as deiined by the appended claims.

:: :

~1 -55-

Claims (15)

THE EMBODIMENTS OF THE INVENTION IN WHICH AN EXCLUSIVE
PROPERTY OR PRIVILEGE IS CLAIMED ARE DEFINED AS FOLLOWS:

1. An automatic position control system for slitters for dividing a moving web, comprising, upper and lower rails mounted above and below said moving web, upper and lower racks, respectively, mounted on said upper and lower rails, a plurality of upper slitter stations with cutters mounted on said upper rail and having driving gears which engage said upper rack, a plurality of lower slitter stations with cutters mounted on said lower rail and having driving gears which engage said lower rack and said upper and lower slitter stations arranged in associated pairs so as to cut said web, a plurality of motors with one in each upper and lower slitter station and connected to said driv-ing gears to move said upper and lower slitter stations on said upper and lower rails, a plurality of electronic con-trol modules with different addresses and one in each upper and lower slitter station respectively, connected to one of said plurality of motors, a main control computer, an address and data bus connected between said main control computer and each of said electronic control modules for the addressing of individual modules and for the transfer of data signals between said computer and said modules so addressed, and means for supplying command signals to said control computer to cause it to transmit commands and posi-tion data on said bus to selected module addresses to cause said motors to position said upper and lower slitter stations.

2. An automatic position control system for slitters according to Claim 1 including, wherein said plurality of motors are step motors and said plurality of electronic control modules supply pulses to said motors in response to said positioning data.

3. An automatic position control system for slitters according to Claim 2, including a plurality of home limit switches with one home limit switch mounted on either lower or upper electronic control modules of each slitter station and electrically connected to the associ-ated electronic control module to halt said module in response to its reaching a predetermined home position.

4. An automatic position control system accord-ing to Claim 1, wherein the control computer is configured to execute a monitor routine which continuously monitors the electronic control modules at their addresses to cap-ture data indicative of the status of the slitter stations and record their positions, and to leave that monitor rou-ine and execute appropriate alternative routines upon detection of position data to be transferred to a module or a fault condition in a module.

5. An automatic position control system for slitters according to Claim 4, wherein the status data cap-tured from the electronic control modules includes data as to whether the associated slitter station is in a home position as indicated by the condition of a home limit switch which stops the station at a predetermined home position.

6. An automatic position control system for slitters according to Claim 5, including a control routine for returning slitters to their home position, said control routine establishing an operating sequence in which the con-trol computer transmits command to move each slitter by a distance greater than its maximum possible distance from its home position, whereby the home limit switch associated with each slitter will arrest it as it reaches its home position.

7. An automatic position control system for slitters according to Claim 5, including a present position memory array storing data received from said electronic control modules as to the present positions of the slitter stations, said array being updated using data captured by said monitor routine, and a position in said array relat-ing to a specific slitter station being reset to indicate that said slitter station is at a home position on capture of data to that effect from the associated electronic con-trol module.

8. An automatic position control system for slitters according to Claim 7, including a future position memory array storing data entered in said control computer as to intended future positions of the slitter stations.

9. An automatic position control system for slitters according to Claim 8, including a control routine establishing an operating sequence in which the computer compares the present and future position memory arrays to determine which slitter stations are to be moved and through what distance and in what direction, moves the stations to be moved through the least of the distances so determined, and repeatedly determines which remaining modules still need to be moved and through what distance, and moves said remaining modules accordingly, until all of the modules have reached the positions stored in the future position memory array.

10. An automatic position control system for slitters according to Claim 8, including a control routine for causing a slitter station to move through a predeter-mined distance, said control routine establishing an operat-ing sequence in which the computer addresses the electronic control module associated with the slitter station, and generates a number of pulses proportional to the distance to be moved, said slitter station incorporating a motor drive receiving said pulses and causing the slitter station motor to move said slitter station through a unit distance for each pulse received.

11. An automatic position control system for slitters according to Claim 1, including a plurality of manual move switches with one manual move switch mounted on either the upper or lower electronic control module of each slitter station and electrically connected to the associated electronic control module to allow manual con-trol of the slitter station, and including means to make data available to the computer at said control module as to displacement of the slitter under such manual control.

12. An automatic position control system accord-ing to Claim 1, wherein said means supplying command signals to said main control computer comprises a manual console.

13. An automatic position control system accord-ing to Claim 1, including a monitor for displaying the positions of said slitter stations.

14. An automatic position control system accord-ing to Claim 1, including means to permit command signals sent to one of each pair of upper and lower slitter stations to be supplied to the other slitter station so that they move to the same position.

15. An automatic position control system accord-ing to Claim 1, including a plurality of wear detecting switches respectively mounted on said upper and lower elec-tronic control modules of each slitter station and supplying electrical signals thereto for warning the computer of wear of the slitters.