HandlingStation_E!Cokcpit

---

---

Preparation: Handling Station

Goal

• To get to know and describe the structure and functionality of the handling station

The station should mount a top part (which is on the right side) on top of a bottom part (which is on the left side). The station uses 2 different double acting cylinders and a pneumatic gripper.

The functionality of the station can be seen in this video: https://www.youtube.com/watch?v=Jav9SERe0sE

Handling Station Behaviour

• The resting position of the station is when the gripper is not engaged, the gripper is lifted and the transfering cylinder is pulled in!
• On command (by a tappler or other user input), the gripper should move down, close, move backup.
• Transfer the piece forward, move down, release.
• Then the station should return in its resting position.

---

In Software development, state machines are a tool that is very often used, to visualize and understand the behaviour of a machine, before developing the code of the controller.

States A state represents a condition or situation during the life of an object where it satisfies some condition, performs some activity, or waits for some event. For example, consider a traffic light:

• Green Light: The traffic light is green, allowing cars to go.
• Yellow Light: The traffic light is yellow, indicating that cars should prepare to stop.
• Red Light: The traffic light is red, stopping cars from going.

Each of these represents a different state of the traffic light.

Transition Conditions A transition is a change from one state to another. It occurs in response to an event and can have conditions that must be met for the transition to occur. These conditions are known as transition conditions or guards.

For example, in the traffic light scenario:

• The transition from Green Light to Yellow Light occurs after a certain period, say 60 seconds.
• The transition from Yellow Light to Red Light happens after 5 seconds.
• The transition from Red Light back to Green Light might occur after a pedestrian button press and a timer event.

These conditions ensure that transitions happen in a controlled and predictable manner.

Example Let's consider a simple state machine for a door that can be in three states: Closed, Open, and Locked.

• Closed State: The door is closed.
• Open State: The door is open.
• Locked State: The door is locked.

Transitions might be:

• From Closed to Open: When someone pushes the door handle.
• From Open to Closed: When the door is pushed shut.
• From Closed to Locked: When someone locks the door.
• From Locked to Closed: When someone unlocks the door.

In this case, the transitions depend on events like pushing the handle or locking the door.

By modeling these states and transitions, UML state machines help in understanding and designing the logical flow and behavior of systems.

Source: ChatGPT

---

Concept of Entry/Do/Exit: States in Detail

In UML state machines, each state can be divided into three parts: entry, do, and exit activities. These parts help to define what happens when the system enters, stays in, and exits a state.

1. Entry Activity: This action is executed when the system enters a state. It's like a setup phase. The entry activity is called once when the state is entered.

   • Example: When a door enters the Locked state, the entry activity might involve engaging the lock mechanism.

2. Do Activity: This action is performed while the system remains in the state. The do activity is called continuously or repeatedly while the system is in the state.

   • Example: While the door is in the Locked state, the do activity could be continuously monitoring the lock status to ensure it remains secure.

3. Exit Activity: This action is executed when the system exits a state. It's like a cleanup phase. The exit activity is called once when the state is exited.

   • Example: When the door exits the Locked state (i.e., it is being unlocked), the exit activity might involve disengaging the lock mechanism.

Example with Entry, Do, and Exit Activities

Let's revisit the door example with these activities included:

• Closed State:

  • Entry: Ensure the door is fully shut.
  • Do: Monitor for handle push.
  • Exit: Prepare to open the door.

• Open State:

  • Entry: Move the door to the open position.
  • Do: Keep the door open and monitor for someone pushing it shut.
  • Exit: Prepare to close the door.

• Locked State:

  • Entry: Engage the lock mechanism.
  • Do: Continuously ensure the lock remains engaged.
  • Exit: Disengage the lock mechanism.

---

Summary

• Entry Activity: Called once upon entering the state.
• Do Activity: Called continuously while in the state.
• Exit Activity: Called once upon exiting the state.

These activities provide a clear structure for what should happen during different phases of a state's lifecycle, making the system's behavior more predictable and easier to manage.

Source: ChatGPT

---

---

---

Assignment: Handling Station

Connect to PLC

📌 Please note that this scanning process can take multiple trials to detect the PLC. If a PLC is not detected immediately, scan again.

After detecting the PLC, click Apply All to add the PLC to your project

Note that now the PLC has been added to your project.

This has only added the PLC module itself. But the PLC has other modules attached to it that were not yet scanned for. Every module adds new functionality to the PLC. For example, module 750-430 is an 8-channel digital input card. Meaning that the wire-plugs on the 750-430 accept digital sensors like an inductive sensor, light beam sensor, etc.

If you are wondering what a certian module does, search its module number online.

The PLC in this session has 5 modules inserted between the PLC and the End Module. Note that the End Module has to always be there at the end.

The scan results should identify 5 modules. Click add all to add all modules to the project

After adding all scanned modules, your device structure should look like this:

---

Connections to the PLC

State Machine as Enumeration

State machines can be implemented as enumerations in ST.

In the case of state machines, each enumeration element represents a state.

To create an enumeration in e!Cockpit, navigate to Program Structure in the bottom left corner, right click on Applicaition and select DUT.

Example of an enumeration with unspecific state names. Note: you have to give states meaningful names (e.g., MOTOR_FORWARD, MOTOR_BACKWARD, etc.) not call the states STATE_1, STATE_2, etc.

PLC_PRG and the Switch Case Statement

Signal Mapping

The PLC is wired to the conveyor belt's components as follows:

In the PLC_PRG create all necessary variables!

Component	Input address	Output address
1S1	%IX1.0
1S2	%IX1.1
2S1	%IX1.2
2S2	%IX1.3
1M1		%QX0.0
1M2		%QX0.1
2M1		%QX0.2
2M2		%QX0.3
3M1		%QX0.4

In this step you will connect programmed variables to hardware outputs. (Compareable to the labels in the Festo FluidSIM environment with the "Multipolverteiler")

Implementation

📌 Every state machine should include the INIT state. This is the first state the program should run when powered. If you didn't include an INIT state in your preparation, include one now.

PROGRAM PLC_PRG
VAR
    state : STATES := STATES.INIT;
    Entry : BOOL := TRUE;
END_VAR

CASE state OF

    //-----------------STATES.INIT-----------------------------------------

    STATES.INIT:
        IF bEntry THEN
            bEntry := FALSE;
            // insert "entry" code here. This code will be carried out only once upon entry to the state.

        END_IF
        // insert "do" code here. This code will be carried out every PLC cycle while the program is in this state.

        //exit
        IF <exit_condition_here> THEN
            bEntry := TRUE;
            state := STATES.<next_state_here>;
            // insert "exit" code here. This code will run only once upon exiting this state. 

        END_IF

    //-----------------<next_state>-----------------------------------------

    STATES.<next_state_here>: // repeat the pattern above for every state.
        .
        .
        .
        .
        .
END_CASE

// retracts cylinder 1
b1M1 := FALSE;
b1M2 := NOT b1M1; // this makes sure that not both outlets are actuated

// extends cylinder 2
b2M1 := TRUE;
b2M2 := NOT b2M1;

---

Timer / Delay

Your timer declaration may look like this:

When attempting to use the timer in the main program, you may see the following TON documentation.

This timer function block (of type TON) accepts 2 inputs, namely IN and PT, and gives us 2 optional outputs, namely Q and ET.

To check if the timer has counted untill the end, check if timer.Q is TRUE. Do not forget to reset IN after the counter has finished counting, otherwise the counter wont be usable again.

Upload the code