A Solution to Contiguous and Overlapping Parts in Sensor BasedVibratory Bowl Feeders

Gary P. Maul and Nebojsa I. Jaksic

November 9, 2000

1

1 Introduction

A part feeder can be defined as a device which receives a number of randomly oriented parts at its

input and delivers parts in a certain unique orientation at its output. Part feeders can be divided

into vibratory and nonvibratory feeders [4]. The most versatile and the most widely used type of

part feeders is the vibratory bowl feeder [1].

In a vibratory bowl feeder, parts move along the track of the bowl. The orientation is performed

by the mechanical devices mounted along the track. By adjusting these devices, the vibratory bowl

feeder can be configured to feed a part in a specific orientation. The feeder must be taken off-line

and retooled whenever the part or the desired orientation is changed. The flexibility of these feeders

can be increased by replacing the mechanical devices with a sensory device and an air jet.

While traveling along the track of a vibratory bowl feeder each part settles into one of a finite

number of stable orientations. This means that these parts are easier to recognize then randomly

oriented parts. As a consequence, the resolution of a sensor system does not have to be very high.

Traditional camera vision systems are cost prohibitive which limits their application in industry.

Simple machine vision systems cost about $50,000 [6]. The cost of a machine vision system depends

on the kind of images obtained, the speed of image processing and the image resolution.

Image processing algorithms for low resolution systems are usually simple thresholding or edge

detection algorithms. Pattern recognition algorithms deal with tasks like recognition of single or

multiple objects, nontouching or touching parts and nonoverlapping or occluded parts.

Cronshaw at al. [7] developed a flexible assembly module using a vibratory bowl feeder. The

part is fed by the bowl in any one of its stable orientations onto a transferring belt. When the part

reaches the end of the belt, a pusher moves it past an inspection station. The station consists of

a lamp, a prism to reflect light sideways onto the side wall of the track, two thin lines of optical

fibers embedded in the track (one across each wall) and a semiconductor linescan camera. The

image of the part is formed by rapid scans of the camera. The pusher is used to ensure that the

1

part travels at a constant speed while passing the inspection station. A 2D binary image is built

by the camera. Next, a microcomputer analyzes the image, decides whether the part is scrap or

not, and whether it is in the correct orientation.

In other work a Programmable Silhouette Recognizer (PSR) was developed (Fig 1) [2]. A simple

sensor system is mounted in the bowl track at the outlet of the bowl feeder. A grid formed by

light sensors functions as a camera. A light source is placed above the sensor grid. The system

uses a small microcomputer to memorize and recognize parts silhouettes. An air jet is mounted

in the bowl wall at the outlet of the bowl feeder. Its function is to return parts with the wrong

orientation back into the bowl and to allow parts with the correct orientation to pass. The light

and dark information is converted into digital signals by 16 phototransistors. Each workpiece is

represented by a unique 16-bit digital pattern. An enhancement to this system allows it to handle

a sequence of different parts [4, 5]. The system is capable of delivering a programmed sequence of

parts in prescribed orientations at the outlet of the bowl feeder.

The advantages of the sequential vision system are obvious. Such a system can greatly reduce

the number of vibratory bowl feeders in a factory. It also increases the flexibility of the feeding

system.

There are, however, a few problems with the PSR system. It cannot handle contiguous or

overlapping parts. Also, the procedure of setting up the system is somewhat complex and time

consuming. The resolution of the system is only 16 bits, which is not enough to obtain a detailed

image. This may restrict the system’s applications to simple part geometries and orientations that

can be easily distinguished.

2 Problem Statement

The primary goal of this research was to further increase the flexibility of vibratory bowl feeders

and eliminate the problem of contiguous or overlapping parts. In this study a programmable sensor

base vibratory bowl feeder[2] was observed. In order to aid the development of the bowl feeder

2

Figure 1: The Programmable Silhouette Recognizer

3

control algorithm a Vibratory Bowl Feeder Development System was designed and implemented.

The system consisted of the hardware and the software subsystems. The hardware subsystem

included an IBM PC type computer, an SDK-86 computer[3] and a part feeder simulator. The

software subsystem contained communication programs, simulation programs, a data visualization

program, a data acquisition program, and a control program.

The problem of constructing the most appropriate sensor grid for the vibratory bowl feeder

was also addressed. First, different grid choices were compared, then, computer simulation was

performed, and finally, a new grid was designed and built.

During the operation of the vibratory bowl feeder, workparts move along the track of the bowl

in long ”chains”. These ”contiguous parts” presented a problem to the image recognition algorithm

previously implemented in the bowl feeder. Overlapping parts presented a similar problem.

Both of the above issues were subjects of study in this research. A solution was presented,

implemented and tested. The software part of the solution was implemented in algorithmic form

as a part of the feeder control program.

3 Hardware Organization

3.1 Background Information

The block diagram of the vibratory bowl feeder development system is presented in figure 2. Figure

3 shows the electric diagram of the system connections.

An Intel SDK-86 microcomputer is used as the control computer. It has an 8086 CPU, a 16

bit bus and 3 16 bit I/O parallel ports. This allows the use of a single command to input 16

bit data into the computer. Another important reason for choosing an 8086 microprocessor based

architecture is software compatibility. With the fast paced evolution of personal computers and

their wide spread use, a large number of software development packages have become available.

Software used in this research is described in the next section.

4

Figure 2: Block Diagram of the Feeder Development System

5

Figure 3: Electric Diagram of the Feeder Development System

6

3.2 Feeder Development System

As in the PSR, 16 fibers convey light and dark information to 16 phototransistors which act as

voltage amplifiers or logical ON/OFF switches. A phototransistor turns on when light shines on a

fiber optic cable. When there is no light the phototransistor is turned off. Information from the

sensor system enters the control computer. An air jet controled by a solenoid is used to reject parts

when commanded by the computer. When the solenoid is in the on position air flows freely thus

rejecting all parts not correctly oriented. The control computer is connected to the development

computer. The development computer is an IBM 80386 based PC with a VGA monitor, an 80287

math coprocessor, and an EPROM programmer.

3.3 Sensor Configuration

In order to improve the system’s flexibility, and solve the contiguous and overlapping parts problem

a sensor strip was developed and placed in the bowl track and side wall. As the part passes directly

over the sensor area, a control program samples all 16 sensors as fast as possible producing the

image of the part.

The sensor strip is actually made up of fiber optic cables. Such a cable consists of a light

conducting core and a shield. Let t denote thickness of the cable shield and d denote the distance

between two holes in the sensor grid. Any part feature whose width, w does not satisfy the following

condition

w > 2t+ d (1)

may not be registered by the sensor system. A light source is positioned directly above the sensors.

From the end of the fiber-optic cable which is inserted into the sensor strip, approximately 1/16in

of the insulation can be removed. Then, the sensor is inserted back into an opaque sensor strip.

A transparent piece of plexiglass is fixed on the top of the sensor strip to protect the sensors from

dirt and mechanical damage. The sensor strip is made from opaque material.

7

3.3.1 Three-Dimensional Sensor Configuration

A three-dimensional sensor configuration is depicted in Figure 4. Seven sensors are used to obtain

the workpiece shadow image from the plane view and another seven sensors gather information

about the object from the side view. These two images should be enough to recognize many

different parts. Two light sources are applied to create two light beams that fall directly on the two

sensor arrays. In this case different parts/orientations can be detected using all three dimensions

of the part.

The above configuration was implemented and tested. A case study was done for one part.

Results were satisfactory. All of the part’s configurations were differentiated.

Fiber-optic cables convey only light and dark information to the group of 16 phototransistors

which are placed away from the feeder [4]. The phototransistors create binary data that is input

into an SDK-86 microcomputer via its parallel port. The next section will describe the computers

used in this research.

3.4 Computer System

3.4.1 MCS-86 System Design Kit (SDK-86)

An SDK-86 microcomputer is used in the feeder development system as a control computer. The

SDK-86 contains an 8086 CPU, a 16 bit bus, a keypad with an LED display, one serial port, and

three parallel ports PA, PB and PC. In this system P1A and P2A ports are used for sensor input.

P1C parallel port is configured through software as an output port and is used to control the

solenoid which operates an air jet. The software development center is connected to the control

computer via an RS-232 serial connection. The serial line is used to load programs into the SDK-86

and to transfer image data to the development computer for the further off-line analysis.

3.4.2 Vibratory Bowl Feeder to SDK-86 Interfaces

There are two interfaces between the bowl feeder and the SDK-86 system. The control coil of the

air valve is connected to the computer via one transistor and the P1C parallel port. Only the first

8

Figure 4: Three-Dimensional Sensor Configuration

9

line of the port is used. When the signal is sent from the SDK-86 it activates the coil of the air

valve thus opening it. The air jet is on as long as the signal from the SDK-86 is active.

The second interface is one that connects the SDK-86 with light sensors. Two 8-bit parallel

ports, P1A and P2A, are configured as input ports. These two ports form one 16-bit port, PA. The

light coming from light sources enters a fiber-optic cable at the sensor array location. Then, light

travels through the cable until it reaches one of the 16 phototransistors. The on/off state of each

phototransistor is stored in memory as a pixel.

3.4.3 Part Simulator

The fundamental reason for constructing a part simulator was to provide an ideal environment for

testing data acquisition and pattern recognition algorithms implemented in the control program.

The simulator sends signals to the PB parallel port of the SDK-86 microcomputer thus substituting

the sensor system of the bowl feeder.

The simulator consists of a pulse generator and a binary counter. The part simulator can

generate only simple combinations of symbols. With small hardware changes different images can

be obtained.

4 Overview of Software

4.1 Communication Programs

The group of communication programs used in this study consists of four programs. The programs

were developed specifically in order to upload/download binary information to/from the SDK-86

system.

In order to upload data from one computer to the other there was a need for two routines. One

of the routines should send data and the other should receive it. If the communication goes both

ways, two more routines are necessary. Therefore, for two way inter-computer communication and

data transfer, four routines were required. In this study, three of these routines were developed

10

as individual programs. The fourth one was embedded inside the control program of the SDK-86

machine.

PCTO86 is the program that sends data from the PC to the SDK-86 computer over the serial

RS232 line. Its source code was written in assembly language.

The PCTO86 program was developed to transmit binary files which can be executed on the

SDK-86 system. The name of the file to be transmitted was supplied as an argument to the

program. After the whole file was transmitted, a proper message was printed, the file closed and

the program ended.

At the other side of the serial line the data was accepted by the program TR86, which resides

in the memory of the SDK-86. This program waits for the data, inputs the data into the SDK-86

registers and stores it in RAM.

A pair of programs were designed to transfer the raw image data from SDK-86 for further off–

line analysis. The image data consists of two arrays. The data array includes the pixel information

of the image, i.e. the changes in pixel values which occur while the scanned part passes over

the sensor area. The time array presents the durations of the changes in the pixel values. The

above arrays of corresponding pixel/duration information form an image template of the workpart

introduced into the feeder. As a part of the control program, inside the image capture subroutine,

a piece of code was written with function to send the image information over the serial line.

The program 86TOPC was developed to receive raw data from the SDK-86 computer over the

serial line. This program was specifically written for the image templates obtained by the feeder

control program, and it was running on the PC side.

4.2 Vibratory Bowl Feeder Control Program

The feeder control program was developed in order to solve the contiguous and overlapping parts

problem. The vibratory bowl feeder control program was developed in three stages. In the first

stage, an ideal case was assumed, i.e., all the parts were assumed to have identical features, and

11

they were all traveling at constant speed. Also, the sensor strip was presumed to be a sensor

line, and all of the sensors had the same threshold value. Based on the above premises a feeder

control program was developed. In the next stage, testing of this program was performed with the

simulator. Finally, the program was tested and changed so to perform reliably in its normal working

environment. An analysis of the simulation results as well as the real world tests are presented in

the next section.

In this section only the final version of the feeder control program FEEDER is described. The

program was designed to operate with an IBM PC microcomputer connected to the SDK-86 system.

It can receive data from the optical sensors, send commands to the air jet, create an image of a

given sample part/orientation, and recognize the part/orientation whose image it has stored in

memory. Also, the program’s ease of use can cut down operators training costs considerably.

The operation sequence of the control program is rather simple. After starting the communi-

cation program on the PC, the program FEEDER is started from the SDK-86 keypad. Next, two

noncontiguous parts are placed in desired orientation in the bowl feeder, in front of the sensor strip.

Finally, the bowl feeder is turned on.

The first part passing above the sensor strip was used to determine the overall part’s length.

This information is used to set the length of the smallest feature that is registered by the program.

The second part was utilized for the actual feature extraction. The program can be stopped at any

time by pressing the interrupt key at the SDK-86 keypad. The program goes to the beginning if

no part passes by the sensor strip for about 45 seconds.

Port P2, set to be an input port was used to input data from the optical sensors; port P1C,

configured as an input port was used to restart the program; port P2C, configured as an output

port was used to transmit commands to the air jet.

12

4.2.1 Feature Extraction Subroutine

The subroutine IMCAP captures data coming from the optical sensors, creates an image of the part

passing above the sensors, stores the image data in memory, and sends feature/time information

over the serial port. A flow–chart of the image generation subroutine is shown in figure 5.

After initializing appropriate variables and registers IMCAP checks if there is any object at

the sensor strip. It waits until the strip is cleared. Then, it samples data at the rate of about

15µs while waiting to detect the leading edge of the first part. Once the leading edge of the part

is detected, feature extraction routine stores the feature width, height and length in memory. If

the part’s geometry is too complex, i.e., the number of features exceeds 256, IMCAP exits after

stroring the 256th feature in memory.

Calculating the length of the workpiece is straightforward. All stored length entries are added.

Based on this, precision is set as some part of the length size. Next, the whole procedure of

getting image data is repeated. The only difference is that now the precision value is set, and the

features whose length is shorter than this value are not stored in memory. The reasoning behind the

introduction of the precision variable is copying with noise corrupted data. After storing an image

in memory, procedure IMCAP sends image data to the software development center for further

analysis.

4.2.2 Image Recognition Subroutine – IMREC

The flow–chart of the image recognition part of the control program, subroutine IMREC, is shown

in figure 6. This subroutine performs different tests on input data to determine if the tested part

is touching the part in front of it, if it is in the right orientation, and if the feature sequence

corresponds to the template stored in memory.

The operation of the image recognition subroutine can be explained by using an example. Let

there be two contiguous parts entering the sensor area. The procedure is sampling optical sensors

while waiting to detect the leading edge of a workpiece. If data is equal to zero NOTOUCH flag

13

Figure 5: Flow–Chart of IMCAP Subroutine14

Figure 6: Flow–Chart of Subroutine IMREC15

is set to 1. Every time the waiting loop is executed a counter is incremented and the 45 second

time-out condition checked. When the leading edge of the first part is detected NOTOUCH flag is

tested. Since the flag is equal to 1, it means that this part is not contiguous with the part in front

of it, and that it’s current feature is the first feature of the part.

Next, the part’s first feature is compared to the first template entry. Let the first part be in the

correct orientation. Since there is a match, the procedure goes into a loop constantly inputing data

and checking it against the first value of the width/height template. When the next feature of the

part is detected the program exits the loop and a new test is performed. This test compares the

length template value in order to determine the last feature of the workpiece. If that last feature

is not detected, the program repeatedly checks until the data matches the width/height template

value, and then locks in a loop for the duration of the current feature. If the correct feature could

not be detected during the tolerance period the part in question would be rejected. This routine is

performed until the end of the last feature is reached. The first part matched the template, so it

was not rejected. The program loops back to test the second part entering the sensor area.

This time, the program inputs data and finds that it is different from 0, therefore, it realizes

that this part is contiguous with the part in the front of it. Then, the program checks if the data

just obtained corresponds to the first feature of the stored image. If there is a match the program

proceeds as in the case of the first part – locking in the loop while the feature lasts, and then

checking all other features as they pass by the sensors. In this example none of the parts was

rejected, even they touched each other. Therefore, the contiguous parts problem was solved.

If the first detected feature of the second part is not equal to the first template entry, this does

not necessarily mean that the second part is in an incorrect orientation. For some part geometries,

the first and the last feature may look the same, so the program can not distinguish between the

end of the first part and the beginning of the second. In order to deal with such part geometries,the

test is performed using the second template entry. The data is compared with the second feature

of the image stored until it matches it, or until the tolerance length is exceeded.

16

The REJECT procedure returns parts in incorrect orientations to the bowl. First, a delay of

about 10ms is introduced. Then, the air jet is turned on for at least a period of about 30ms. After

this period expires the air jet remains in the on state until the sensor area is cleared.

4.2.3 Overlapping Parts Problem Solution

When the two (or more) parts overlap, their joined image differs from the image stored in memory.

So, all of the parts that overlap would be rejected. There is a special case when one part is exactly

on the top of the other and their joined shadow matches the shadow of a single part. Then, the

sensor strip placed on the bottom of the bowl feeder track can not provide a solution. Instead,

a 3–D sensor configuration must be used because the side view of a single part differs from the

sideview of multiple parts stacked on top of each other.

5 Test Results

5.1 Simulation Results

At the first stage of the control program development, the part simulator was used to test the

program’s logic. There were three basic tests performed. The first test consisted of sending one

part orientation for feature extraction and a different one for part recognition. The control program

performed correctly, never failing to reject a wrong part.

The second test consisted of sending a large number of noncontiguous parts, all correctly ori-

ented. The control program was executed three times for a period of 10 minutes each time. Each

time it rejected one correctly oriented part out of 756 parts.

The third experiment tested the behavior of the program when the parts were contiguous. The

wrong part was always detected. When all the parts were in the correct orientation, the program

rejected one part out of 751 parts.

One theory that explains the rejection of the correctly oriented parts is as follows. The sampling

rate of the control program differs slightly from the part simulator’s clock rate. These two are not

17

synchronized. So, when the program compares a part’s features with the image stored, it does

not start at the very edge of the arriving part. Each time a new part arrives the program starts

checking the first feature slightly further from the real edge. Finally it misses one count, concludes

that the part is not in the correct orientation and rejects it.

5.2 Implementation Results

The control program that was performing almost ideally with simulated inputs was tested with

the optical sensors and the vibratory bowl feeder. At first, the air jet would not obey computer

commands. After checking the signals it was decided to send the control signal to an open collector

driver first, and then, connect the output of the driver to the air jet.

At the next run the program rejected all the parts. Analyzing the data off–line it was discovered

that no two images were the same. Feature lengths varied from part to part. The precision at which

the program was detecting the length was calculated next. At the maximum part speed of about

4 in/sec and at the sampling rate of about 125 µs, a feature would be recognized if its length was

larger than 0.0005 inches. The precision was even greater when the part moved slower.

There were two possibilities considered which could cause erroneous readings of the feature

extraction algorithm. The first was that the parts were manufactured with a precision which was

less than the precision they were measured by the program. This could be easily solved by reducing

the sampling rate. The second possibility was that the velocity of each part varied as the part was

passing through the sensor area.

Another problem, also detected off–line, was that the features were not ”stable.” It appeared

like the sensor in question was taking some time to decide if the feature was there or not.

Both of the above problems were solved. The changing velocity and the precision problem were

solved together by introducing a variable “precision” into the control program. Features of a part

were not considered constant. They were allowed to vary up to a given precision. The precision

was set based on the overall size of the part. In this new version of the control program, two parts

18

were needed to pass through the sensor area in order to obtain an applicable image. The first part’s

data was used to determine the part’s length and set precision. The feature extraction subroutine

IMCAP used the precision value to determine if a feature was “stable” or not whileı-xtracting the

feature from the second part.

A number of tests were performed setting different values for the precision variable. The control

program would sometimes allow many incorrectly oriented parts to pass through, and sometimes

it would reject all incoming parts. Observing the images off–line one could see that if the precision

was set to a small value, all the features were not stable. If this value was large, then not all

the features were recognized and therefore, some incorrectly oriented parts were not rejected. The

above problem was solved by a simple action of moving the light sources further away from the

optical sensors. Apparently, the instability of features was caused by the light intensity, reflection

and refraction. When the light sources were close there was enough light entering optic cables to

falsely trigger some phototransistors.

5.3 Case study

With the precision value set to 1.5625 % (1/64) of a part’s length, a number of tests were performed.

A light–weight, opaque plastic part of complex geometry is presented in figure 7. The total number

of parts in the feeder was kept constant during tests. In the tests, whose results are given below,

parts moved at about half of the maximum speed, i.e. about 2 parts per second.

Let us analyze briefly the part’s geometry and its impact on the part’s suitability for feeding by

a sensory based vibratory bowl feeder. The part can be in one of 14 stable positions/orientations.

The lower the center of gravity of the part’s orientation, the higher the probability that the part will

be in that orientation. Therefore, the highest probability orientations are the ones in which a part

touches the track of the bowl feeder with a side whose dimensions are given by the part’s length

and the part’s width. There are 4 such sides, and they all can be differentiated from each other.

The same holds for the next 4 orientations - sides where the part’s length and height touch the

19

Figure 7: Part Used in Tests

track. The last 6 orientations, where sides defined by height and width touch the track, are much

less likely to occur, but they are also separable. As a potential problem area one could identify

small feature dimensions, specifically dimensions of “teeth” in the “comb.”

One part orientation was chosen to be the correct one (the largest flat side down and the comb

turned towards the bowl). During the first test 200 parts were inspected. 38 parts were in the

correct orientation and 2 pairs were touching. The control program rejected 4 parts in correct

orientation and did not reject 3 parts which were incorrectly oriented.

Before conducting any more tests, the brightness of the light sources was decreased. The

second test was conducted with 100 parts, out of which 24 were correctly oriented and 3 pairs were

touching. The control program rejected 9 correctly oriented nontouching parts. All incorrectly

oriented parts were rejected. Examining closer the path parts were traversing while being scanned

by the sensors, an obstacle was detected. Namely, holes were drilled on the side of the track in

order to accommodate optical sensors. The lowest hole was positioned with the edge at the track

20

level. As a remedy, the rough edges of the hole were filed down.

In the third experiment all 100 parts were correctly oriented. The program rejected 12 parts

the first time, 23 the second time and 7 the third time it was running.

The fourth experiment was performed with all 100 parts touching. During the first run of the

program the parts were randomly oriented. There were 13 parts in correct orientation and 2 of

them were not recognized. All 87 incorrectly oriented parts were rejected. The second run of the

program was executed under the same conditions. There were 19 parts correctly oriented, and 3 of

them were rejected. All the incorrectly oriented parts were blown back into the bowl. During the

third run of the control program all parts were correctly oriented. The program rejected 8 parts

out of 100.

In experiments, the overlapping parts problem never occurred when the parts were randomly

oriented. In order to test the control program 20 parts were positioned so to overlap while passing

through the sensor area. They were always rejected.

From the test results presented above, it may be concluded that the described hardware, ac-

companied by the described software solved the contiguous and overlapping parts problem. At this

stage the results are highly dependent on the light intensity and/or sensor threshold values.

The light sensitivity of the vibratory bowl feeder control program may not be a disadvantage.

If used properly it can increase sensitivity of the system to different part geometries. For example,

if a workpiece has a small hole, this feature would be detected if the light intensity is high and/or

the optical sensor threshold low. But, if the light intensity is low and the sensor threshold high

the hole would probably be missed by the feature extraction subroutine. A small protrusion, on

the other hand, has greater chances of being recognized if the light intensity is low. Intense light,

and an optical sensor with large receiving area would not detect a small protrusion, although they

would detect a small hole.

21

5.4 Programming Considerations

One of the objectives of the feeder control program design was to minimize the time the bowl

feeder spends off–line while the new workpart is programmed. The start up time of the system is

in the range of few minutes, providing that the control program is already in ROM of the SDK-86

computer. Only two operations are needed to start the program. Once the program is running, all

that is needed is to place two workpieces in correct orientation and start the feeder.

In case that the light sources are not at the appropriate distance and the program is not

performing correctly, it can be interrupted and started again in less than a minute. The other

option is to wait for about 45 seconds with the feeder turned off, readjust the lights, place another

two parts at the track of the bowl, and turn on the feeder again. This operation can take less than

two minutes. So, the start-up operation of the bowl feeder can take less than 5 minutes. Tuning

the system can take longer and it depends on the part geometry and size, as well as the previous

lightning conditions. Programming a new part orientation, once the system is running, can be done

in less than 2 minutes.

The start-up time for the program which sends data to an IBM PC takes longer (10 to 15

minutes). It involves starting the PC, running the communication program, sending the control

program to the SDK-86 computer, starting the data acquisition program on the PC, and starting

the feeder control program on the SDK-86 system.

Once the data is in the PC, it can be looked and analyzed while the feeder control program

is running. A menu–driven software package for the off–line analysis is operational but still under

development.

There is another advantage of the above system. Namely, the cost of training the operators

which would be responsible for operation of the bowl feeder system is low; there are only few simple

commands needed to start the program the first time. Parts programming does not require any

special skills.

22

6 Conclusions

This paper addressed the problem of recognizing the correct part orientation even when the scanned

part is touching or overlapping another part. A solution to the contiguous and overlapping parts

problem was reached by combining the increased precision and speed of the new hardware, results of

an analysis of optical sensor configurations, and a specially developed bowl feeder control program.

An analysis of sensor configurations in the sensor area was performed. The results lead to a

3–D implementation as the most promising, therefore a number of optical sensors were positioned

at the side wall of the track of the bowl feeder. The data obtained from the sensors represented the

bottom view and the side view of the part scanned. Also, instead of a sensor grid, a sensor strip

was introduced. This change alone made the software part of the solution to the contiguous parts

problem possible. In addition, the sensor strip increased the precision of the system manifold.

Communication programs were developed in order to provide faster data flow between the

SDK-86 system and the software development computer. These programs were heavily used while

debugging the feeder control program and for the off–line analysis of the part’s image data.

The vibratory bowl feeder control program, with the appropriate hardware, can handle con-

tiguous and overlapping parts. Also, it is easy to use. The start-up operation of the program can

take less than 5 minutes. Programming a new part may take less than 2 minutes, and it does not

require any manual data entry.

Correct operation of the program depends on the appropriate location of the two light sources

used. Although this may be considered to be a disadvantage of the described system, it may be

used to the system’s advantage. Namely, by analyzing a part’s features, an operator may choose to

use more or less light depending on which part features he wants to be emphasized. Some features,

like protrusions, are easier to recognize if there is less light. Small holes would require more light

to trigger a phototransistor.

23

References

[1] G. Boothroyd, C. Poli, and L. Murch, Automatic Assembly, Marcel Dekker Inc., New York,

1982.

[2] Lee Devlin, A Vision System for Determining Part Orientation in a Vibratory Bowl Feeder,

Unpublished Master Thesis, Pennsilvania State University, 1981.

[3] SDK-86, MCS-86 System Design Kit, Users Guide, Intel Corporation, CA

[4] Chao Ou-Yang, A Study of Workpiece Sequencing in a Sensor Base Vibratory Bowl Feeder,

Master Thesis, The Ohio State University, 1986.

[5] Gary Maul, Chao Ou-Yang, “Predicting the Cycle Time for a Sequence of Parts in a Sensor

Based Vibratory Bowl Feeder”, Int. J. Prod. Res., 1987., vol 25, no. 12, pp. 1705 – 1714

[6] Chuck Jada, “Laser Measurements on The Shop Floor”, Automation, Aug. 1991., pp. 34 – 35

[7] A. J. Cronshaw, W. B. Heginbotham, and A. Pugh, “A Practical Vision System for Use With

Bowl Feeders”, Robot Sensors: Volume I – Vision, U.K., 1986.

24