LogixPro
Automatic Control of Conveyor belt of
bottles
Getting Started
There are always numerous ways to accomplish tasks in programming, but a quick review of the
Allen Bradley bit shift instructions should surely point to them as an ideal tool for use in this
particular process. In the bottle line simulation, we are faced with detecting and tracking a few
Boolean details having to do with the bottles entering the line. Sensors are provided to detect the
presence of a new bottle, the bottle sie, and whether the bottle is fully intact. !ssentially " Boolean
states describing the properties of each bottle that enters the line. If we analye the various ways
that we might process these bottles, it should quickly become apparent that we will have ample
information for making such decisions, assuming we keep track of it.
A single BS# or BS$ instruction can be used to track a single Boolean state %& or '( which in)turn
can describe a unique property of a product. In the initial e*ercise you will be asked to track the "
Boolean values describing each bottle entering our process line. The Boolean states will be referred
to as +!*ists+, +$arge+, and +Broken+ and these states are to be tracked by you, utiliing " separate
BS$ %bit shift left( instructions. It can be argued that +!*ists+ need not be tracked %,correct(, as
bottles continuously enter the line, and therefore must e*ist. -e will even use this fact to strobe our
BS$ instructions and cause a shifting of our tracked information. $ater when you start diverting
broken bottles to scrap however, they will no)longer !*ist. These missing bottles could be detected
after they are scrapped by using the +Broken+ state, but for now I want you to track all " states using
" separate bit arrays.
..........
Exercise #1 -- rac!ing t"e bottles
.reate a program which allows the operator to start and stop the process using the available panel
mounted switches. -hen the process is running, the main conveyor should be energied, and
bottles should continuously enter and e*it the line. /or these e*ercises please utilie the bits in word
B"0& if and when single bits such as flags etc. are required.
1tiliing $S' %!*ists(, strobe " BS$ instructions to shift " separate bit arrays consisting of two '2 bit
words each. 3lease use files 4B"05, 4B"06, and 4B"02 for this purpose. By restricting you to these
particular files in the binary table, it will be much easier for you, and your instructor to monitor what
is happening with your program using the data table display.
Test your program out, and using the 7ata Table display monitor, take note of how the bits
representing +!*ist+, +$arge+, and +Broken+ are being shifted within their appropriate bit arrays. 8ou
may find that it will be necessary to slow the scan rate using the slider in the 3$. panel to see this
activity clearly. If your program is operating correctly, you should now have a means of determining
the properties associated with each bottle that passes down the bottling line.
..........
Exercise ## -- $tili%ing t"e &oolean 'ata
If you paid careful attention to the bits being shifted along in each bit array, you would have likely
noted that there is an offset between each of these " arrays. This is due to the fact that the " limit
switches are located e*actly 5 bottle widths apart. In order to use $S' to strobe the data from all "
switches at the same time, this spacing is actually critical, and must be an e*act multiple of a bottle
width. The number of bottle widths in)turn determines the offset we encounter within our arrays.
-e cannot easily compensate for this offset when using a BS$ instruction as the switch data will
always load into bit & of the array. There may be ways to overcome this, but for these e*ercises it
will be your responsibility to compensate for these offsets. 8ou will have to ad9ust for this whenever
you employ any of these bits to determine a particular bottle:s properties.
;odify your program so that all $arge bottles are diverted to the lower conveyor located on the right
hand side of the simulation. This is to be accomplished by utiliing the appropriate bit in the +$arge+
bit array to invoke the transfer. Also, please ensure that the bottles are not damaged in the process.
If you are successful in completing the above, you should be well prepared to deal with the task of
diverting broken bottles to scrap
..........
Exercise #( -- &oxing t"e &ro!en &ottles
To add a little interest to the simulation, I:ve decided to have you grind up the broken bottles that
occasionally come down the line. <f course it is your responsibility to ensure that the ground glass is
placed into bo*es, and to bring new bo*es into place as required.
The cost of providing cardboard bo*es can be significant over time. /or this reason it is essential
that you fill each bo* to it:s ma*imum capacity, and do so without spillage. Since a small bottle only
produces 5=" as much ground glass as a large bottle, you will have to ad9ust for this difference in
your program logic.
In creating the logic for this e*ercise, you may find that you are faced with initialiing variables or
clearing counters etc. each time you edit and then restart your program. >ust to make it a little easier
to find this logic, I would ask that you add the following rung to the top of your program.
There is no sense cluttering up your program with logic that only e*ecutes once each time it is run,
so please place this logic into a subroutine where it is out of the way, yet easily located.
<nce you have come up with a solution for the scrap problem, then you are now entering the home
stretch.
..........
Exercise #) -- *ill and Ca+ t"e &ottles
There aren:t many details that need to be e*plained about the filling operation. !nergiing the fill
tube solenoid <05=2 will cause the fill tube to e*tend and enter the positioned bottle. 8ou then must
make a choice of discharging a large or small quantity of product into the bottle utiliing the
appropriate charge solenoid <05=? or <05=@. <nce again, the Boolean data contained in the bit
arrays will be used in determining the correct action to be taken.
The bottle capping station control should be 9ust a matter of capping each bottle that comes along.
The capping ram solenoid <05=A must be energied to e*tend the ram, but you need not ad9ust for
bottle sie with this particular capping equipment. Attempting to cap a bottle that does not e*ist will
cause little harm, but is a waste of caps, plus adds to clutter on the plant floor. 7ue to the foregoing,
ensure that you only cap bottles that actually e*ist.
I will leave issues such as when to stop and start the line to you. Beep in mind however, that we
want to maintain the highest level of production possible with the equipment at our disposal.
<nce you have the filling and capping operations operating at ma*imum efficiency, we can then
move on to the 9ob of keeping the operator fully informed of the production details.
..........
Exercise #, -- rac!ing t"e Production -umbers
The operator control panel has been equipped with four, quad digit $!7 displays. In order to reduce
the I=< count required in our 3$., quad displays containing a built in latch were selected. -ith this
particular type of display, data is only transferred into the latch from the '2 data lines while the latch
enable connection is held high. If the latch enable connection is then taken low, the last state of the
data lines is latched, and the $!7s will continue to display this data until the ne*t time the latch
enable line is taken high.
Since the displays may be individually written to by strobing the appropriate latch enable line from
low to high, and then to low again, we can wire them to the same '2 data lines which are in)turn
wired to the '2 bit output card addressed at <06. To control the four latch enable lines, unused
terminals on output card <05 were selected.
8our task, should you accept this assignmentCgrinD, is to update the multiple*ed displays with the
running totals of the large and small bottles produced, bottles scrapped, and bo*es filled. The rate at
which the updates take place, should be high enough that single counts are not skipped, but not so
high as to burden the 3$. unnecessarily.
This particular task of updating the $!7 displays lends itself well to modulariation, and ideally
should be e*ecuted in a subroutine. !ven if you call this subroutine unconditionally each scan, there
are still benefits to this approach. 3lacing this logic where it will be out of the way, yet readily
accessible can make for a much less cluttered, and easier to read program.
<nce you have the completed the foregoing, all that should be left is to handle the details. Allowing
the operator to set the count of bottles to be processed might be a feature worth implementing.
#eviewing your program and making certain that it is clearly documented is a must. Adding
something new such as tracking equipment run time is an option.
..........
Exercise #. /0+tional12 -- 3ust a small 4odification
In the introduction to this series of e*ercises for the bottle line, I stated that +There are always
numerous ways to accomplish tasks in programming+. In order to prove the statement was accurate,
I:m now going to ask that you modify your program so that BS# %bit shift right( instructions are used
in place of BS$. At the same time, I also want you limit yourself to the use of 9ust 5 bit arrays for
tracking the bottle properties.
If only the +$arge+ and +Broken+ bit arrays are used, you should still be able to determine if a bottle
e*ists by e*amining the +Broken+ property of the bottle. This of course assumes that the broken
bottle has been diverted to scrap, and therefore no)longer e*ists.
-hile you are making the required modifications, carefully review the AB documentation for the BS#
instruction, and see if you can come up with a way of eliminating the offset we had in the previous
bit arrays.
