Patent Publication Number: US-10781052-B2

Title: Dynamic gapping conveyor system

Description:
BACKGROUND 
     The invention relates generally to power-driven conveyors and in particular to controlling conveyor speed upstream of a processing station to maximize throughput. 
     In many package-handling applications, packages on a conveyor have to be sorted, weighed, or scanned. And in many of those cases, the packages must be sorted, weighed, scanned, or otherwise processed individually. So packages are commonly conveyed in single file separated by interpackage gaps. Gapping conveyors are used to deliver packages either with a fixed gap length or at a fixed pitch to the downstream processing conveyor feeding the sorter, scale, or scanner. The processing conveyor is generally run at a constant speed determined by the processing speed of the sorter, scale, or scanner. If the speed of the infeed conveyor or other conveyors upstream of the gapper is too high, packages accumulate and the gapping conveyor has to be stopped. Because of latency in stopping and restarting, throughput is compromised. If, on the other hand, the speed of the infeed conveyor is too low, the rate of delivering packages is below the capacity of the processing station. 
     SUMMARY 
     One version of a conveyor system embodying features of the invention comprises an infeed conveyor conveying packages at an infeed speed and a separation conveyor receiving the packages from the infeed conveyor and conveying the packages in a conveying direction at a separation speed greater than the infeed speed to separate consecutive packages across gaps. A sensor detects the lengths of the packages in the conveying direction at a sensing position on the separation conveyor and produces a sensor signal indicative of the lengths of the packages and the gaps. A gapping conveyor receives the packages from the separation conveyor and spaces the packages with a fixed gap length or with a fixed pitch. A processing conveyor receives the packages from the gapping conveyor and delivers the packages at a processing speed to a processing station. A controller receives the sensor signal to compute the lengths of the packages and the gaps on the separation conveyor and makes a speed adjustment to the infeed speed as a function of the lengths of the packages and the gaps. 
     In another aspect a method of controlling the supply of packages to a processing station, comprises: (a) conveying packages in a single file at an infeed speed; (b) separating the packages across interpackage gaps by accelerating the packages to a separation speed higher than the infeed speed on a separation conveyor; (c) measuring the lengths in a conveying direction of separated packages and the interpackage gaps leading or trailing the packages; (d) computing a string length of a string of a predetermined number of consecutive separated packages and interpackage gaps from the measured lengths; and (e) adjusting the infeed speed as a function of the computed string length. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       These features and aspects of the invention, as well as its advantages, are described in more detail in the following description, appended claims, and accompanying drawings, in which: 
         FIG. 1  is a top plan schematic of one version of a conveyor system embodying features of the invention; 
         FIG. 2  is a top plan schematic of another version of a conveyor system embodying features of the invention; 
         FIG. 3  is a block diagram of a control system usable in a conveyor system as in  FIG. 1  or  FIG. 2 ; 
         FIG. 4  is a top-level flowchart of one version of a control scheme for operating a conveyor system as in  FIG. 1  or  FIG. 2 ; 
         FIG. 5  is a timing diagram of one realization of a control scheme as in  FIG. 4 ; 
         FIG. 6  is a flowchart of an exemplary interrupt service routine for measuring package and gap lengths in implementing the control scheme of  FIG. 4 ; and 
         FIG. 7  is a flowchart of an exemplary infeed motor speed-adjustment control task for adjusting the speed of the infeed conveyor to maximize throughput in implementing the control scheme of  FIG. 4 . 
     
    
    
     DETAILED DESCRIPTION 
     One version of a conveyor system embodying features of the invention is shown in  FIG. 1 . In this version an infeed conveyor  10  running in a conveying direction  12  at an infeed speed X conveys packages in a single file to a separation conveyor  14  running at an accelerated higher separation speed Y. The speed-up provided by the separation conveyor  14  interposes gaps G between the packages. The separation conveyor  14  delivers the packages one at a time to a gapping conveyor, or gapper  18 , which comprises a series of smaller conveyors that are selectively and individually started, stopped, or run at different speeds to feed packages to a downstream processing conveyor  20  with a fixed gap g between consecutive packages. The processing conveyor  20  conveys the packages to a processing station  22 , such as a sorter, a checkweigher, a scanner, or the like, at a speed Z, corresponding to the rate at which the processing station can process the packages; i.e., the processing-station capacity. 
     A sensor, such as a photo-eye  24  and reflector  25  or a light curtain, is used to detect the lengths of packages and interpackage gaps G on the separation conveyor  14  at a sensing position  27 . The sensing position  27  is far enough downstream of the infeed conveyor  10  that packages being measured have cleared the infeed conveyor and are being conveyed in the conveying direction  12  at the separation conveyor&#39;s speed Y. For the optical sensor described, the sensor&#39;s light beam is blocked by the passing package. The duration of the blocked beam is proportional to the length L of the package measured in the conveying direction  12 . And the time during which the light beam is not blocked is proportional to the length of an interpackage gap G. 
     The nominal speed Z of the processing conveyor  20  is set to maximize throughput as limited by the capacity of the processing station  22 . And the nominal speed X of the infeed conveyor  10  is set to match the rate of product delivery by the processing conveyor  20 . For a given fixed gap g between products on the processing conveyor  20 , the nominal infeed speed X is set to maximize throughput. If packages on the infeed conveyor  10  are abutting without intervening gaps, the nominal infeed speed X would be set to Z·L/(L+g). For example, if the processing conveyor runs at Z=100 ft/min and requires fixed gaps of g=0.5 ft and all the package lengths L=0.5 ft, the nominal infeed speed X=50 ft/min. If all the package lengths L=1.5 ft and 0.5 ft gaps are required, the nominal infeed speed X=75 ft/min for a fixed processing speed Z=100 ft/min. Because package lengths can vary, the speed X of the infeed conveyor  10  is changed dynamically to maintain maximum throughput by feeding packages at the required rate. 
     A similar conveyor system is shown in  FIG. 2 . The only difference is that the gapper  18  delivers packages to the processing conveyor  20  so that the pitch P, measured in the conveying direction  12  from trailing end to trailing end or leading end to leading end of consecutive packages, is constant. 
     The conveyor systems shown in  FIGS. 1 and 2  are controlled by a controller  26  as shown in  FIG. 3 . The controller may be a programmable logic controller, a laptop or desktop computer, or any general-purpose programmable device running a customized software control program, which may be stored in and run from a program memory element  28 , such as a ROM or EPROM. Computations and other data are stored in a volatile memory element  29 , such as a RAM. The controller  26  also has an internal or external clock  30 , or timer. A user interface  32  allows a user to monitor and adjust the operation of the conveyor. The output  33  of the sensor  24  is connected to a controller input  34 , such as an edge-detecting input. The controller has an output  36  that controls the speed X of the infeed conveyor via its drive motor or motors  38 . The controller  26  can also have other inputs and outputs to control the speeds of the processing conveyor and the separation conveyor, as well as the gapping conveyors. And the controller  26  can have other sensor inputs necessary for controlling the gapping and other conveyors. 
       FIG. 4  is a high-level overview of one version of a control scheme used to adjust the speed of the infeed conveyor to maximize throughput. First, the length of the separation conveyor occupied by four consecutive packages in a package stream and the interpackage gaps immediately preceding or following each of those four packages is measured by adding the lengths of the four packages and the four gaps. That sum is functionally related to the speed of the infeed conveyor: the greater the sum, the slower the speed, and the smaller the sum, the faster the speed. If the sum indicates a speed above the maximum allowable or the desired speed of the processing conveyor, the infeed conveyor&#39;s speed is decreased by the percentage the infeed speed is above the processing speed plus, optionally, a safety factor to account for inaccurate length measurements due to sensing errors or side-by-side packages, or doubles. For example, if the average length of a package is 8 in and one in ten packages is a double, a safety factor of 8/10 in (0.8 in) would be added to the sum in determining the speed adjustment. The infeed speed is similarly increased less an optional safety factor if the sum indicates an infeed speed below the speed of the processing conveyor. The sums of package lengths plus gap lengths are computed as a running sum updated by dropping the lengths of the leading package and gap and adding the lengths of the last of the next four packages and gaps. In this way a new running sum of four package lengths and gaps is computed with each new package, and the speed can be adjusted at that repetition rate. The number of packages in the sum (four, in this example) is determined by the number of packages that the gapping conveyor can handle at one time. 
       FIG. 5  is a timing diagram that shows a typical record of the output  33  of the sensor. The output sensor is shown as a high level L when a package is blocking the sensor&#39;s beam. The duration of the high level L is a measure of the length of the passing package. During interpackage gaps the sensor&#39;s output is a low level G. Of course, the sensor&#39;s output level could alternatively be low when the beam is blocked and high when not blocked. 
     Although there are many ways to implement the control program stored in the program memory and executed by the controller, the following example of one realization of the control program is provided to explain the operation of the conveyor system. Whenever a low-to-high or a high-to-low transition in the sensor output signal  33  is detected on the controller&#39;s edge-detecting input  34  ( FIG. 3 ), an interrupt is generated by the controller that causes an interrupt service routine  40  in the controller&#39;s operating program to run. The time periods G, L during which the interrupt service routine runs are indicated by the rectangles in  FIG. 5 . On a rising edge of the sensor output signal  33 , indicating the end of a gap and the leading edge of a package on the separation conveyor, the interrupt service routine&#39;s program steps G, which determine the length of the gap and start a length counter or timer to time the length of the package, are executed. The falling edge of the sensor signal  33 , indicating the end of a package and the start of a new gap, is detected by the controller&#39;s edge-sensitive input  34  ( FIG. 3 ), which generates an interrupt that causes the interrupt service routine  40  to run. On a falling edge, the routine executes program steps L to compute the length L of the package from the length counter&#39;s count and to reset a gap counter for measuring the duration of the next gap. Because the passages of packages and gaps past the sensing position along the separation conveyor do not coincide, a single counter could be used as both the gap counter and the package-length counter. 
     The interrupt service routine&#39;s rising-edge program steps G also bid a speed control task to run to adjust the speed Z of the infeed conveyor. The speed Z is adjusted depending on the length of the separation conveyor spanned by a string of N consecutive packages and the N gaps trailing (or leading) each of those packages. The predetermined number N of packages in the string is set by the number of packages that the gapping conveyor can handle at one time; i.e., the gapper&#39;s package capacity. In this example, N=4. 
     For a controller that does not have an edge-sensitive input  34  ( FIG. 3 ) that generates an interrupt on both rising and falling edges, but that rather has a rising-edge-sensitive input and a falling-edge-sensitive input, the output of the sensor would be connected to both. In that case the gap-measuring routine G (running upon detection of a rising edge) and the package length-measuring routine L (running upon detection of a falling edge) would be separate interrupt service routines. Of course, it would also be possible to execute the code of the interrupt service routine or routines on a non-interrupt level by sampling the output of the sensor often enough to timely detect changes in the state of the sensor from high to low and vice versa. Under that scenario the sampling routine could bid a task that appropriately executes the G or the L, i.e., the gap or package-length measuring, program steps. 
     A flowchart describing the operation of the G and L program paths in an interrupt service routine that runs on either a rising edge or a falling edge of the sensor signal is shown in  FIG. 6 . Upon detecting a rising or falling edge on the edge-detecting input, the controller&#39;s interrupt handler transfers program execution from an active task to the interrupt service routine. First, the routine determines at step  50  whether a rising edge or a falling edge of the sensor signal caused the interrupt. If a falling edge, indicating the end of a package and the start of a gap, caused the interrupt, the interrupt service routine follows path L and starts a gap timer in step  52 . Before or after starting the gap timer, the routine stops a length timer in step  54 . The count in the stopped length timer is a measure of the length (LENGTHCOUNT) of the most recently detected package. The routine also sets a length flag in step  56 . The length flag indicates that a package length is available for the computation of the infeed speed. If, on the other hand, a rising edge of the sensor output signal, indicating the end of a gap and the detection of the leading edge of a package, caused the interrupt, the routine follows path G and starts the length timer at step  53 , stops the gap timer at step  55 , and sets a gap flag at step  57 . The gap flag indicates that a gap length (GAPCOUNT) is available for the computation of the infeed speed. Then, regardless of whether the interrupt was caused by the leading edge or the trailing edge of a package, the routine, in step  58 , bids a speed adjustment task to run. Then program execution exits the interrupt service routine and returns to the interrupted background task running when the interrupt was generated or to a pending higher priority task. Other tasks may include gapping-control and user-interface-handler tasks, for example. 
     The speed adjustment task, bid by the interrupt service routine and shown in the flowchart of  FIG. 7 , is scheduled to run by the controller&#39;s task manager. First, the task, at step  60 , checks to see if the gap flag, indicating the end of a gap and the leading edge of the next package, is set. If not, the task, at step  62 , follows path K and checks the state of the length flag. If it&#39;s not set, the task ends. If it is set, indicating the trailing end of a package and the start of a gap, the task, at step  64 , clears the length flag set by the interrupt service routine. At step  66 , the task stores the stopped count (LENGTHCOUNT) of the length timer in a circular buffer L(j) in the volatile memory, where j is an index into a buffer of N locations. Then the index j is incremented at step  68 . If the index j exceeds the buffer length N, the index j is reset to 1 at step  70 . Finally, at step  72 , the count LENGTHCOUNT of the package-length timer is reset to zero in preparation for the leading edge of the next package. (By setting LENGTHCOUNT to zero before the start of the next package, i.e., by zeroing the length counter&#39;s count, the count of the length counter when the counter is stopped equals LENGTHCOUNT. But if the counter is not zeroed, LENGTHCOUNT can alternatively be computed as the difference between the counter&#39;s count at the start of the package and the count at the end of the package.) Then the task ends. 
     If, at the start of the task, the gap flag is set, the task follows path M and clears the gap flag at step  74 . At step  76 , the task stores the stopped count (GAPCOUNT) of the gap timer in a circular buffer G(i), where i is an index into a buffer of N locations. After incrementing the index i at step  78 , the routine resets the index i to 1 if it exceeds N at step  80 . The count GAPCOUNT of the gap timer is reset to zero at step  82  to prepare for measuring the next gap. Then the length (STRING_LENGTH) of the string of the previous N packages and the gaps following each are computed at step  84  by adding the contents of both circular buffers G(i), L(j). Thus, STRING_LENGTH is a running sum of a string of N package lengths and N gap lengths recomputed for the N most recent packages as each new package is measured. In other words the STRING_LENGTH computation in this example is realized by a finite impulse response (FIR) digital filter with equal coefficients for all the gap and package lengths. The string length is inversely proportional to the speed X of the infeed conveyor. 
     If the separation speed Y equals the processing speed Z, the string length (STRING_LENGTH) of the package string of N consecutive packages and their trailing gaps G on the separation conveyor is compared directly to the string length (PROC_LENGTH) of a string of N packages and their trailing gaps g on the processing conveyor. (If the speeds Y and Z are not equal, STRING_LENGTH is scaled by the factor Z/Y, the ratio of the processing speed to the separation speed, before being compared to PROC_LENGTH. Or, equivalently, PROC_LENGTH can be scaled by the reciprocal factor Y/Z.) The difference (step  86 ) in lengths (DELTA_LENGTH) represents a difference in speeds. The percent difference in the lengths (DELTA_LENGTH/PROC_LENGTH) spanned by the string of N packages on the separation conveyor and the same string on the processing conveyor relative to the length of the string of N packages on the processing conveyor is computed in step  88  and is used to determine a dynamic adjustment (SPEED_ADJUSTMENT) of, for example, that same length-difference percentage to the infeed conveyor&#39;s speed. The speed adjustment (SPEED_ADJUSTMENT), if down, is further lowered by an optional safety factor (SAFETY_FACTOR). If the speed adjustment is upward, it is decreased by an optional safety factor, which may be the same as or different from the safety factor for a slowdown. The speed of the infeed conveyor is sped up or down accordingly in step  90  by a motor speed signal sent over the controller&#39;s control output  36  ( FIG. 3 ) to the motor or motors  38  driving the infeed conveyor. The length of the package string (PROC_LENGTH) of length N on the processing conveyor for the equi-gapped packages of  FIG. 1  is computed as the sum of the lengths of the N packages plus Ng (the total length of N fixed gaps of length g). If an average package length is used, PROC_LENGTH can be treated as a constant for a given processing speed Z. For the equi-pitch processing conveyor of  FIG. 2 , the length of the package string (PROC_LENGTH) on the processing conveyor is a constant: N·P (the product of the number of packages and the package pitch). 
     The embodiments described in detail are used as examples for descriptive purposes. Alternatives exist. For example, the sensor used to measure package and gap lengths could be a proximity switch, a weight sensor, a visioning system, or any sensor capable of detecting package and gap lengths. As another example, the control program is described as adjusting the infeed speed by an amount equal to the length-difference percentage between packages on the separation conveyor and the processing conveyor plus or minus a predetermined safety factor. But other functional relationships between the speed adjustment and the lengths of the packages and the interpackage gaps are possible. For example, different safety factors could be used for different adjustment magnitudes or different safety factors could be used for speedups and slowdowns. Or the percentage speed adjustment could be less or more than the length-difference percentage. As another example, instead of recomputing the running sum as each new package is entered, the sum could be recomputed with every other new package or with the next group of N packages. Or as another alternative, the FIR filter used to compute STRING_LENGTH could be replaced with a recursive, or infinite impulse response (IIR), digital filter that computes a STRING_LENGTH from a previous STRING_LENGTH output as an input along with the new package and gap lengths appropriately weighted. For example, the IIR filter could be implemented as a lowpass filter in the speed adjust task by the recursion equation: STRING_LENGTH i =Aα[L(i)+G(i)]+(1−α)STRING_LENGTH i-1 , where 0&lt;α&lt;1 and A is a constant equal to a string length N.