STUDENT QUESTION: LADSIM Bytronic Industrial Control Trainer (ICT3)

Page 5

Any advice on this problem would be much appreciated.

The final part of the problem states:


Use the Component Detect sensor IP4 as an index to allow for multiple components on the belt conveyor.

Use the Reject Area sensor IP5 to detect when a part is at the reject area and determine from the data captured previously whether the component needs to be accepted or rejected. Use the Reject Solenoid OP3 to reject bad components off the conveyor.


So, I am assuming Bit Shift Registers are used.


Also, the I/O are given "Non-detection status" of 'High' or 'Low'.

I think a bit (1 or 0) is used to energise the reject sensor IP5 which in turn energises piston OP3.


Otherwise somethings get accepted and rejected out of order.

So, first I need to differentiate between:


A. Correctly assembly = ring ON peg.

B. NOT correctly assembly = peg ONLY.

C. NOT correctly assembly = ring ONLY.

Ah.


In writing code for this earlier, I did not pay attention to the IO initial states, i.e. High or Low.


This impacts what they do when you implement them as NOC or NCC.


I treated them all as being LOW.


So, for example, IP3 isn't Low rather it is High, therefore, it behaved the opposite to what I expected.


Slowly this is making sense.

This code rejects NOT complete components, i.e. individual unassembled pegs and rings.


I initially thought, I'd have to write two lines of code, one for pegs and one for rings but a single line of code works for both.





Reject NOT complete components:




--| |3--|/|8--| |4--| |5--( )0

Ah.


It also rejects Completed assembled components.


Maybe I do more than one line of code.

Step one: write code to differentiate (a) assembled components and (b) NOT assembled components (individual pegs and rings).


Step two: write code so the output for the above should be via a Bit Shift Register to ensure everything coordinates correctly.


Step three: work out how a Bit Shift Register can be used to implement this.


Step four: the output of the bit shift register (1 or 0) will be a trigger for IP5 which energises the piston OP3.

I need to eliminate duff code:


ATTEMPT 1



--| |5--|/|3--( )3


AIM: EVERYTHING is rejected UNLESS it is correctly assembled.


REALITY:
When implemented, the Completed assembly items are not rejected and are counted. Good.


HOWEVER, the NOT complete assembly items are not rejected either. Bad.




ATTEMPT 2



--| |3--|/|8--| |4--| |5--( )0


AIM: Reject NOT completed components ONLY.


REALITY:
When implemented, rejects NOT completed components. Good!


HOWEVER, also rejects Completed components. Bad!

The course notes do not contain the relevant information needed to answer this question - they only contain a brief overview of how LADSIM works.


There is no guidance on how to analyse and solve a problem - no examples of any methodological approaches.


The explanation of the code available is too concise and there are relatively few examples of the code.


Although there is a list of textbooks, the notes do not contain directed reading.


One of the online books, Bolton, W. (2009) Programmable Logic Controllers, explains how to implement a program to keep track of items an a conveyor and use a sensor to detect faulty items and reject them using a piston.


The information is in Chapter 11: Shift Registers.


I developed the basics of this before I found it in the textbook; that boosted my confidence!


If you're attempting to use Bit Shift Registers, you obviously need to know how they work with your simulation software.


Again, there is relatively little useful information in the course notes and there is no software manual!


Luckily, the information was available online thanks to students:


http://www.freestudy.co.uk/plc/bytronics%20work%20sheets.pdf


However, even these notes don't explain that with LADSIM in the BIT SHIFT REGISTER options, you click on the option "Outputs" to successfully implement their example code.


To complete the last part of this exercise, I needed to design:


1. A method of differentiating between assembled and non-assembled items.


2. A method of inputing this data into a Bit Shift Register.


3. A method for shifting this data along the register for each new item.


4. Using this data to reject non-assembled items using a piston.


Now that I know how Bit Shift Registers work in LADSIM, I can write and test the code.


The course notes are too concise and there is no manual for the software - a relatively straightforward exercise was made needlessly harder!

I've hit a wall with this.


The problem states:

The inductive and capacitive sensors IP8 and IP3 simultaneously detect the properties of an item.
IP8 detects metal and so is activated by either single pegs or assembled pegs.
IP3 detects the presence of an object adjacent to the sensor and is positioned in such a way that it only detects an assembled ring. Further down the belt, the through-beam sensor IP4 senses any passing item.


The problem requires:

• Use the Belt Peg Detect sensor IP8 and the Ring Assembled sensor IP3 to determine whether the component is a correctly assembled part.
• Use the Component Detect sensor IP4 as an index to allow for multiple components on the belt conveyor.

IP3 - Ring Assembled - HIGH

IP8 - Belt Peg Detect (also detects assembled!) - LOW

IP4 - Component Detect - HIGH


I have written several codes to differentiate between assembled and non-assembled.


HOWEVER, I cannot differentiate between Ring Assembled (peg AND ring) and a peg.


AIM:


If not correctly assembled (only peg or ring), put 1 bit into register.


If correctly assembled, put 0 bit into register.


Use IP4 (Component Detect) to shift an item every time one passes it.


Any help would be much appreciated.

I have attempted the following lines of code:


--|/|3---- Detects Correctly Assembled items and Pegs. So, sends 1 Bit to Register even when item Correctly assembled. Only want to send 1s if NOT assembled.
| |
--| |8----


--| |3---- NOT WORK. Signal is permanently on.
| |
--|/|8----



--|/|3--| |8-- NOT WORK. When peg passes it briefly lights up NOC8 but doesn't send signal across the rung!


--| |3--|/|8-- NOT WORK. Signal is pernanently on.


No ladder can differentiate between Correctly Assembled item and Peg.

No ladder can differentiate a Ring.

I attempted to use IP4 to identify a ring and it can be done by adding it to a new rung on the first example code above.

HOWEVER, I also use IP4 to index and Bit Shift the Register for every new item - so there is double counting.

--| |4--[BSR] Code to BitShift the Register.



Any advice would be greatly appreciated.

I have now written functioning code for rejecting individual rings and pegs.


I have now written functioning code to reset the Bit Shift Register after rejection - the distance between IP4 (Component Detect) and IP5 (Reject Area) is so long it allows TWO items to be between those points.


If a reset function is implemented to clear the wrong bit position in the register, the second item will be deleted before it reaches IP5!


The register in this software simulator has 16 bits.


So, if your trigger position for rejection in memory is .in, for example, position 15 and you need to delete the next place, i.e. position 14.


Otherwise, acceptance and rejection of Completed and not Completed items will become out of synch.

My final challange is still differentiating between Completely Assembled and not Assembled (pegs or rings) items.


Originally my plan was:


Completely Assembled items = 0.


NOT Completely Assembled items (pegs and rings) = 1.


The 1's once they reached a specific location in the Bit Shift Register would trigger the rejection piston OP3.



However, it is impossible the way the scanners work to do this!

IP3 detects Completely Assembled items

IP4 detects any item with metal so pegs AND also Completely Assembled items too!


BOTH Completely Assembled items and pegs generate 1 while rings generate 0.




I checked out Vince Delima's video on Youtube he has a fully functioning program: https://www.youtube.com/watch?v=6YFHfiQCqBs


I noticed:


1. Completely Assembled Items trigger IP3 AND IP8 - so, there must be an alternative way to solve this problem.



2. Pegs only trigger IP8 (as expected).


3. Rings ONLY trigger IP4 - can I use IP4 to ID an item AS WELL as bitshifting the bits in memory for each new item detected?


Any help would be much appreciated!