part tracking

I am using a AB Micrologix 1200 and a AB PV+600. I have an accumulating conveyor with 6 zones inside an oven. I need to be able to keep track of what is in the oven and how long it has been in there. My parts need to be in the oven for 20 minutes before being released.
I would also like to be able to adjust the needed time on the PV if necessary.
I am not sure how to keep track of the time remaining and also shift it through the six zones. Any help would be appreciated.

Is this accumulating belt continous on one drive motor?
Do you just need the dwell time of hte oven as a speed setting?

If so, find the length of the oven belt and calculate or measure the rate of travel at a known speed, then scale accordingly.

But if you need accurate tracking of various parts for sorting or such...where you have a continuous belt and need accurate tracking:
1) create a file or reserve a file just for the contents of the oven (or any other continous belt).
2) obtain the most accurate accurate position signal for the belt that you can. Bidirectional encoders are ideal. You can sometimes get by with just a calculation from hand tach readings, depending on what you plan to do with the information.

3) create a register pointer that increments/decrements to match the speed of the line. If you are using an encoder, sum the change in counts each scan to track positon in an integer or long integer before applying any floating point math to it to scale it into appropriate units (depends on product size, line speed and use preference).

If you are tracking tractor tires, use feet, if you are tracking M&Ms, millimeters may be more appropriate.

When a new product enters the system, pop it's identifying value (can be a product code) into the appropriate position in the file (I normally keep a pointer and and offset available, so I can adjust the value for the position of real world sensors).

Then at the exit end of the conveyor, you will need to evaluate the contents of the pointer plus the length of the section. Do this every scan, and make a search loop if it's possible to skip more than one "item unit" per scan.

The item units and the size of the "map" as well as its data type will be determined by the product.

At any time, you can map the conveyor graphically by copying the contents of the file from the pointer to the end, and then from the beginning to the pointer. You can do this via expressions in some HMIs, so there is no mass copying in the PLC.

There is no shifting of a boatload of data this way. The pointer needs to be precise if your product is "fine" in length with regards to the accuracy of your actual speed signal. If your speed is unidirectional and relatively steady, then you can get good tracking even without encoder feedback.

If all six zones are one continuous belt, then you can identify the contents of each zone bya examining windows which are again offset by your pointer (with wraparound controls).

The above method is great for sorters and things that must be geared to product position like diverters or appliers, barcode scanner triggers, etc, but might be overkill if all you need is a number of items per zone count.

The overhead for the above construct is short and sweet, but can involve loops and searching for high speed stuff, and it can blow the mind of persons who must view it in ladder logic...but it's performance makes it better than simple FIFOs in my experience.

Thanks for the reply.
The accumulating conveyor is actually a roller conveyor, not a belt. It is set up with 6 zone sensors which I am able to get a status signal from. It has only one drive motor. The zones are 5ft long as the parts are fairly large.
All I am after is to make sure that each part that enters the oven is in the oven for 20 minutes before being released. There can only be 6 parts in the oven at one time, but as one is released the next one moves into the next zone amking room for another part to enter the oven. So what I need to do is first, see the part enter the oven, then start a 20 minute timer and at the end of the 20 minutes, release the part.
Thanks again for your help.

I would to set it up as an accumulator conveyor, i.e. moves forward a set distance then stop. The distance should be timed so that the 7th increment after going in would see the part exit.

There would be 2 options then.

Option 1
Time the increments for (20/6)-travel time.

or Option 2
Increment the conveyor whenever a new part appears, time stamp each parts entry and store in FIFO. Once a 6th part has entered the first part will wait until the time is entry time + 20. You would have to make the logic take into account the fact that you may not get the 6 positions full, that fist part may have to move 2 or more increments to get out, so again travel timer shold be taken into account.

The accumulating conveyor has 6 preset zones with zone sensors and pneumatic clutch release, so as part enters the conveyor, the first part always goes to the exit end and waits for a release signal. The next part will go onto the conveyor and wait in the second zone and so on until the conveyor is full.

davehask said:

The accumulating conveyor has 6 preset zones with zone sensors and pneumatic clutch release, so as part enters the conveyor, the first part always goes to the exit end and waits for a release signal. The next part will go onto the conveyor and wait in the second zone and so on until the conveyor is full.

Click to expand...

Then I would use the FIFO method, a FIFO with 5 store locations and a register containing the first to leave exit time.

Make it an auto function that when you load the part to enter its exit time in the FIFO, if the exit register is empty then unload the FIFO into that register. Therefore first part in will always go in and straight out of the FIFO. The second part will be loaded into the FIFO and and will wait as the exit register is occupied.

If a part enters on the 53rd minute, add 20 minutes (73) as greater than 60 subtract 60 which leaves you with 13, that equals the exit minute. So the exit register would hold 13 and you would start removing that part at 13-exit time.

Once left you would fill the register with a dummy number (as zero could be a valid exit time, 99 perhaps) once the value = the dummy number then the next part exit time can be unloaded from the FIFO.

You could include seconds if that is important.

Edit: If you don't have a real time clock, then you could use a count value, perhaps increment a register every second and store the count value + 1200. Include a controlled wrap around time in case of continuous parts, also could zero the count when the oven is empty.

A suggested starting point

First, make sure the conveyor can move the product from zone to zone without wrecking - that is, set up your accumulating logic. Once that's working put together some logic to asynchronously move the product data in concert with the physical movements.

Something like: If section A is unoccupied and the upstream section B is occupied, run conveyors A and B. When B clears for X seconds stop its conveyor - this allows time for the product to get completely off of conveyor B and fully onto conveyor A. When product hits sensor in A stop A and transfer the data from zone B (make sure to clear out the data in B) to zone A. Repeat this concept for as many upstream sections as you have.

.02

davehask said:

Thanks for the reply.
The accumulating conveyor is actually a roller conveyor, not a belt. It is set up with 6 zone sensors which I am able to get a status signal from.

Click to expand...

Define "status"

davehask said:

It has only one drive motor. The zones are 5ft long as the parts are fairly large.

Click to expand...

Just for clarity, all the zones move together (no clutches) at the same surface speed, correct?

davehask said:

All I am after is to make sure that each part that enters the oven is in the oven for 20 minutes before being released.

Click to expand...

Then all you need is to run a test and scale the command signal to the measured time it takes one piece through the input and exit eyes.

The command speed sent to the drive must be scaled linearly preferrably between two points other than zero, and then you oven "dwell time" can be the operator control, and the PLC simply scales it (y=mx+b and it's variants) before passing it on to the drive when called for by the mode and status logic.

More questions:
4) Can anything bad happen to the parts to disturb their position on these rollers inducing unpredictable slip?
5) How much slip do you see?

davehask said:

There can only be 6 parts in the oven at one time, but as one is released the next one moves into the next zone amking room for another part to enter the oven. So what I need to do is first, see the part enter the oven, then start a 20 minute timer and at the end of the 20 minutes, release the part.
Thanks again for your help.

Click to expand...

Okay, so take my last abstraction and flip it inside out.

So few objects, nice tight loops, and still, you will know hte length and position of hte oven contents. If you are not comfortable with indirect addressing, read no further.

Know the command speed (measure moving product or the roller surface accurately with a handheld tach) and if variable, obtain feedback and/or speed command being sent to it to figure out how many inches per second this conveyor moves.

At regular intervals, calculate the delta of the position change of the conveyor, and increment the array of products (length 10, because memory is cheap) positions.

But wait how do we get those product arrays in the first place?

We monitor an entry sensor and if possible, use it to measure the length of the product. Pass the result thru a LIM block to see if it qualifies as a real product and not a moth or a power hiccup. If the measurement falls outside the limit, flag an alarm and take appropriate action (if any...maybe these products can go through back to back).

When a product qualifies in length, record the pertinent values in the next available spot in your array(s), starting with the position.

The program that updates the positions of the array, will loop through all ten of them every update period (I like to use an STI for this) by adding the update period scaled into "inches" or "mm" of travel for each active product.

Your loop will check the position to determine the entry time (based on any offset of the entry sensor), exit time, and when to drop it from the list.

This list can be a FIFO, but I prefer a rolling pointer and lots of members of the array structure:

N100:[0-9]:"Product ID Code INT"
F101:[0-9]:"Position"
ST102:[0-9]:Barcode value
N103:[0-9]:"Oven entry time formatted MM:SS"
or
T104:[0-9].acc:"Bake time"

Use your imagination and build in spares.

Then the windows can be adjuastable to match what your sensor(s) see, and even if they fail, you can't get out of sequence, and can activate machinery, sort, and display the products you KNOW are really there accurately.

I spent almost 3 years as a green tire sorter and two of my machines had automatic sorters with FIFO zone based logic, so my first deep venture into PLC programming was to write bullet proof sorting code, so forgive me for the long posts. When you have had to hand carry dozens of tires over a monstrous roller conveyor system to resort them because a moth landed on a photoeye...and do this for months daily...you develop sort of a passion for the subject and a disdain for oversimplified FIFO tracking.

Paul

OkiePC said:

I spent almost 3 years as a green tire sorter and two of my machines had automatic sorters with FIFO zone based logic, so my first deep venture into PLC programming was to write bullet proof sorting code, so forgive me for the long posts. When you have had to hand carry dozens of tires over a monstrous roller conveyor system to resort them because a moth landed on a photoeye...and do this for months daily...you develop sort of a passion for the subject and a disdain for oversimplified FIFO tracking.

Paul

Click to expand...

I can trump you, try 8 years at airports tracking baggage to aircraft loading points and secure baggage areas (1000's of conveyors and 100's of routing combinations). Prior to that 10 plus years product tracking at various food facilities.

FIFO tracking is fine providing you build in timing limits on expected detection at sensors, based on pulses generated by the conveyors. Try reading the description again and visualise what it is doing.


This is irrelevant though, from his description there are sensors at each point and no decsion making at any point (with the exception of time release) and no tracking pulses.

Doug-P makes a valid point, in timing the release of each object, to ensure a gap is maintained. As there are sensors in the oven it would make it easier, release the upstream one when the downstream one has left the sensor.

Thanks for the replies.
The conveyor system is a Lewco accumulating roller conveyor. The accumulating part of the logic is included in the sensors and requires no additional plc logic. I can access the status (part present) or trigger a release signal from any sensor by accessing the signal either before or after the sensor (normally the release signal is only needed for the 1st zone which is at the exit end of the conveyor). This is done by installing a "T" cable either before or after the sensor (each sensor is daisy chained to the next). They use a Sick WTR1-P421S01 sensor at each zone.
My question is more about FIFO's and how they work. As the first part crosses my conveyor input sensor, I would like to start a 20 minute timer and at the end of that 20 minutes, I will send a release signal to the conveyor to release that part. That part will already be sitting at Zone 1 waiting to be released. In the mean time, I will have 5 more parts move on to the conveyor (sitting in Zones 2-6), each needing to be in the oven for 20 minutes. When Zone 1 is released, the part at Zone 2 will automatically move into Zone 1 and so on, without any intervention from the plc. All I need to do is make sure that no part is not released before 20 minutes of cure time is completed.

FIFO - length = 5
Exit Time Register - Length = 1

Start
FIFO 5 = 99
FIFO 4 = 99
FIFO 3 = 99
FIFO 2 = 99
FIFO 1 = 99

EXIT = 99

Time = 2:23 Part Arrives, 23+20 = 43 (doesn't overlap 60 so stay the same)

Load FIFO
FIFO 5 = 99
FIFO 4 = 99
FIFO 3 = 99
FIFO 2 = 99
FIFO 1 = 43

EXIT = 99

FIFO 1 <> 99 and EXIT = 99 so unload FIFO

FIFO 5 = 99
FIFO 4 = 99
FIFO 3 = 99
FIFO 2 = 99
FIFO 1 = 99

EXIT = 43

EXIT <> 99 so check current minute against value 43

Time = 2:42 Part Arrives, 42+20 = 62 (62 > 60, so 62-60 = 2)

Load FIFO
FIFO 5 = 99
FIFO 4 = 99
FIFO 3 = 99
FIFO 2 = 99
FIFO 1 = 2

EXIT = 43

Time = 2:43 (EXIT = 43 = Minute)

First part exits, on exit complete make EXIT = 99

FIFO 1 <> 99 and EXIT = 99 so unload FIFO

FIFO 5 = 99
FIFO 4 = 99
FIFO 3 = 99
FIFO 2 = 99
FIFO 1 = 99

EXIT = 2

EXIT <> 99 so check current minute against value 2.

etc

build in allowance for exit time etc, build in ability to clear FIFO (probably on conveyors run-out)

Dave,

Here is a rough sample of using FIFO registers. It needs lots of work, just a place to start. The key will be figuring out how to put in the branch rung logic on Rung 003 so that the FIFO loads properly under various conditions of 1 part only in Zone 1, or all zones full, or some other amount of zones in use.

Thanks Lancie1.

You are very welcome. You will need to work on Rungs 003 (FIFO Load logic) and 006 (Zone Part Done Unlatch).

On Rung 003, I tried to test out logic to load the FFL using simulated switches, but found it difficult not knowing the exact physical operation. I got it to work in the LogixPro simulator by operating switches to simulate part movement, but most likely I overlooked conditions that will need fixing.

On Rung 006, I stuck in a XIC for the Zone 1 Part Present sensor, but you will probably need something else or something different here to reset the Part Done output at the proper time.

Just for completeness, the FIFO as I was describing (just noticed the 99's in the FIFO I described, those were not required).

I did this in Control Logix, would be just the same in the MicroLogix.

Like any FIFO there should be logic to clear it out if required.