a solution to contiguous and overlapping parts in sensor...
TRANSCRIPT
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