help with a sorting problem

Ok try this...........

Ok.......try giving us a few specifics........
How far are the sensors from the kickers.......
Distance between the sensors......
Distance between the kickers.....
Speed of the conveyor in iches per min .....

No one here will be able to help you until we have a grasp on the physical aspects of the system.....

Dave

Could you work up some kind of rough sketch, say in MSPaint and post it? This would help others to grasp what it is you're trying to overcome.

your picture hope it helps

Your system, as you have described it, does not seem very stable nor reliable.

It appears that you are relying very heavily on timing. This does not provide "positive" control. By using timing, you are "assuming" that the part will be where it needs to be and when it needs to be there. If your conveyor operated in an indexing fashion you could develop a positive timing relationship between the part-type and its position.

I assume, based on what you have said (or rather, not said) that once the parts pass the sensors the PLC has essentially "lost sight" of the parts.

So, it appears that you are hoping to be able to pass "type-bits" through a bit-register, or some-such, at the same speed that the conveyor is moving.

The problem with that approach is that there is nothing to cause the speed of the bit-registers to be synchronized with the speed of the conveyor. Each will be running independently of the other.

If there is the slightest variation in conveyor speed, or if the PLC program is very large... actually, it doesn't matter how large or small the program is...

Even if the speed of the conveyor is absolutely steady, if you don't have a means to keep the two synchronized, the PLC will go out of synch with the conveyor.

However, just for the sake of discussion, let's assume that the speed of the conveyor is synchronized with the speed of the PLC...

You need to have TWO bit-shift registers; one for the High sensor and one for the Low sensor. Both registers need to shift together.

Let's look at the Ejectors (lower right in the drawing below).

The High-Bin Ejector is monitoring the state of Bit-12 in the HIGH-REG.

The Low-Bin Ejector is a little bit different. It has to monitor Bit-12 of the LOW-REG and Bit-14 of the HIGH-REG. If it only monitored the state of Bit-12 in the LOW-REG then it would operate in every slot where there was a High-part, even though the High-part has been already ejected.

       HIGH

      SENSOR

         |

         1   2   3   4   5   6   7   8   9  10  11  12  13  14

       +---+---+---+---+---+---+---+---+---+---+---+---+---+---+

HIGH   | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |

 REG   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+

                     |                               |

               LOW   |                               |

              SENSOR |                               |

                 |   |                               |

                 1   2   3   4   5   6   7   8   9  10  11  12 

        LOW    +---+---+---+---+---+---+---+---+---+---+---+---+

        REG    | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 |

               +---+---+---+---+---+---+---+---+---+---+---+---+

                     H       L       L       L       H       L

    

                                                    HIGH    LOW

                                                     BIN    BIN

                                                    EJECT   EJECT

.
Everytime the registers shift, according to your bit-shift index timer, each ejector responds to the state(s) of the bits that the particular ejector is monitoring. I have assumed that there is always a gap between parts and that the gap is at least as large, timewise, as a part. If so, then after ejecting a part, the next bit will ALWAYS be a zero, thus retracting the ejector.


This drawing shows that there is a 2-bit difference between the two registers. That is, Bit-1 of the LOW-REG is aligned, timewise, with Bit-3 of the HIGH-REG.

Everytime that a bit-shift is to occur, the state of each sensor is loaded into its' respective register.

In this manner, having a part in front of each sensor at the time of a bit-shift is not a problem.

Each sensor should be observed separately and recorded separately.

In terms of the problem as you have described it, if this doesn't give you what you need then you simply MUST explain WHY!

Thyrn, you simply have to know... 90% of the effort required to develop a solution is developing the right question; that is, properly identifying the problem!

(183)


BTW Thyrn, don't leave us hanging... this is interesting and interested minds want to know!

Ok let me try one more time


the hole problem is timing


The convayor moves at a set speed.

I can have the ladder look at the first sensor it get latched then the part hits the low sensor and it gets latched. its a high part so the first hammer will hit it off the belt , but the next part is not seen by the sensor as it hits the high sensor, i can have up to 3 part on the belt at one time being high part or a low part and has to sort them into the right bin without moving the sensors.

i am trying here please understand.

"the hole problem is timing"

I can appreciate that. The "timing problem" is exactly as I described in my previous post with the "drawing".

"I can have the ladder look at the first sensor it get latched then the part hits the low sensor and it gets latched."

The HIGH-REG should record ONLY High-Parts.

The LOW-REG should record BOTH High-Parts and Low-Parts.

Both registers need to shift, TOGETHER, by TIME!

NOT BY EVENT!

Then, as in my example, the High-Bin Ejector needs to look at only Bit-12 of the High-Reg to determine whether or not it should operate.

The number of "bits" between Detection and Ejector Operation depends on how often your bit-registers perform a shift. That is entirely up to you.

Then, in my example, the Low-Bin Ejector needs to look at BOTH Bit-14 in the HIGH-REG and Bit-12 in the LOW-REG.

At any given time, WHILE Bit-12 in HIGH-REG = 1, Operate the High-Bin Ejector.

Likewise, WHILE Bit-14 in the HIGH-REG =1 AND Bit-12 in the LOW-REG = 1, Operate the Low-Bin Ejector.


"its a high part so the first hammer will hit it off the belt , but the next part is not seen by the sensor as it hits the high sensor,..."

What are you talking about?

Are you using bit-registers ??????????????

If not, what are you using? How are you trying to "tell" the Ejectors how to operate?


C'MON, MAN! GIVE US A CLUE AS TO HOW YOU ARE TRYING TO DO THIS!

(229)

Sorting Problems - Tracking Solutions

What Terry Woods has described very well in the post above is a very good object tracking solution. Rather than timers though I would prefer to use a pulse generator (PPI, Tach) attached to the belt. the pulses are generated as the belt moves this would reflect the speed at which the parts are traveling on the conveyor.

As the part passes the first photoeye (I believe you said the High Part Detecter is first) then as long as the eye is blocked a bit is set in the High Part Bit Shift Register. The bits in your High Part Shift Register are shifted with each pulse of the pulse generator.

Your high part ejector will be triggered by how ever many pulses it takes to travel from the high part detecter to the high part ejector. If the pulse generator produced one pulse every half an inch and the high part ejector is 6 inches downstream from the high part detecter then approximatly 12 pulses to activate the ejecter.

Now for the Low Part Detector:
Set up a Low Part Shift Register. To set bits in the low part shift register use the low part photoeye and in conjunction check the High Part Shift Register at the same time. The bit from the high part shift register to look at is the number of pulses from the High Part Photoeye (use the same pulse genertor to shift bits through the Low Part Shift Register). The Low part shift register bits are only set if the low part photoeye is blocked and there is no part present in the high part shift register.

Your Low Part ejecter will be triggered only if there are bits set in the low part shift register how ever many pulses (or distance) from the low part detecter to the low part ejecter.

I hope this helps

Thanx Dan

Here :

all i am using is latch and unlatch with binary bits with rto timer and ton timers

the part hits the first sensors latch a bit hits the second sensor latch another bit it a high part so it get put in the high part bin

low part will not latch the high sensor bit but will latch the low sensor bit so it a low part so its put in the low bin

this will sort one part at a time on the converyor i need to sort more then one part at a time. each part is put on the converyor at differnet times and it keeps puting the on one at a time.


useing a micrologics 1000

Continuous Operation

The the Bit Shifting systems Terry and I are describing are for continuous operation. The conveyor continues to run and the parts are placed on this moving belt. The belt must be moving for the pulse generator to produce pulses, when the belt stops then no pulses are generated.

The part detecters continue to place ONES in the shift registers when ever parts are present and ZEROS are entered into the shift registers whenever NO parts are present. The Ones are just shifted through to the end of the shift registers where the just drop off.

Of course these ONES may pile up in the bottom of your electrical cabinet and may cause electrical shorts if they are not vacuumed out a couple of times a month. Having a good house keeping procedure is always helpful.

Thanx Dan

Dan,
(I was working on this response before your follow-up.... so... ooops)

I appreciate, however, I disagree with your perception of how to "record" the part-type.

The simple method is to examine and record BOTH sensor readings, on a shift-by-shift basis.

Then at the Ejector sites, the High-Bin Ejector simply watches Bit-X (12) in the HIGH-REG. Meanwhile, the Low-Bin Ejector watches Bit-Y (14) in the HIGH-REG and Bit-Z (12) in the LOW-REG.

They shift across in pairs. It becomes a simple matter of "If, and while, HIGH-REG-Bit-12" then operate the High-Bin Ejector.

The "causal factor" for the High-Bin Ejector becomes simply, Bit-12 of the HIGH-REG.

Meanwhile, "If, and while, HIGH-REG-Bit-14 AND LOW-REG-Bit-12" then operate the Low-Bin Ejector.

In this case, the "causal factor" for the Low-Bin Ejector becomes simply, Bit-14 of the HIGH-REG AND Bit-12 of the LOW-REG.

   HIGH-REG

     (12)

  ---|  |-------( High-Bin Ejector )





   HIGH-REG    LOW-REG

     (14)        (12)

  ---|  |--------|  |-----( Low-Bin Ejector )

I don't get it... what's not to see?


(272)

You are using TIMERS ONLY!!!

Is this correct ??????

Ejecter Pairs or Detecter Pairs:

Yes Terry I see where the ejecter looks at the register pairs in your description and this will work very well in this application. My description has the detecters only loading the appropriate register. I have used both descriptions in applications for sorting product. The last reqiured four photoeyes to detect four levels of product and inserted ones into four different shift registers to track the product into four seperate diverts. I used the detecter loading the appropriate register method with this application.

In either case I would still use a PPI to track conveyor movement and not rely on timers for tracking parts.

beerchug

Thanx Dan

One way or another, there needs to be some sort of synchronization.

(306)

this is a wind up yes?

i am new here but seriously people struggle with this sort of stuff?

no offence meant to the guy with the problem but we employee trainee's that wouldn't dare ask for a solution to this, you in the wrong game?

sorry if i have upset anyone.

BTW Terry whats the deal with the (num) on your posts?

Hi again :


And YES i am only using timers i have never programed a shift resister.