Siemens TIA portal
- Thread starter Lee
- Start date
The best way to go online in Siemens TIA Portal is to establish a connection between the programming device and the automation system, and then use the TIA Portal to go online. This can be done via Ethernet, PROFIBUS or PROFINET, depending on the system. Once the connection has been established, navigate to the "Online" tab in the TIA Portal menu and select "Go Online". From there, you can monitor and modify the automation system in real-time.
Can you show me an example of a program written in STL?
Sure, here is an example of a program written in Siemens STL language:
```
NETWORK 1: SAMPLE_PROGRAM
TITLE
// Sample STL Program
END_TITLE
// Declare variables
VAR
Counter : WORD; // Counter variable
Input_1 : BOOL; // Boolean input variable
Output_1 : BOOL; // Boolean output variable
END_VAR
// Main section
NETWORK 1: MAIN
// Load input into memory
LD Input_1
// Increment counter
ADD 1 TO Counter
// Compare counter to 10
CP Counter = 10
// If counter = 10, reset to 0 and set output true
= Counter TO 0
( CP ) LD Output_1 = 1
// If counter != 10, set output false
( )
LD Output_1 = 0
END_NETWORK
```
This program increments a counter and sets an output to true when the counter reaches a value of 10, then resets the counter back to zero. If the counter is less than 10, the output is set to false. This simple program demonstrates the basics of the Siemens STL language.
How do I use an array to move data across a profinet network?
To use an array to move data across a PROFInet network in Siemens TIA Portal, you can follow these steps:
1. Declare an array with data you want to move. For example, to transfer 10 DINT variables, you can declare an array as `MyArray : ARRAY[0..9] OF DINT`.
2. On the sending device, use a SEND instruction to send the array. For example, `SEND MyArray TO MyRemoteDevice` will send the array `MyArray` to the remote device `MyRemoteDevice`.
3. On the receiving device, use a RECEIVE instruction to receive the array. For example, `RECEIVE MyArray FROM MySenderDevice` will receive the array `MyArray` from the sender device `MySenderDevice`.
4. Use the received array on the receiving device as needed.
Here is a sample code that demonstrates sending and receiving an array of 10 DINTs across a PROFInet network:
```
//Declare the array to be transferred
VAR
MyArray : ARRAY[0..9] OF DINT;
END_VAR
//Network that sends the array
NETWORK SendingNetwork:
//Sending instruction sends the array to the remote device
SEND MyArray TO MyRemoteDevice;
END_NETWORK
//Network that receives the array
NETWORK ReceivingNetwork:
//Receiving instruction receives the array from the remote device
RECEIVE MyArray FROM MySenderDevice;
//Use the received array as needed
//For example, print the first element of the array to the console
CONSOLE( MyArray[0] );
END_NETWORK
```
Remember to configure the proper network settings in TIA Portal, such as IP address and routing, to ensure the data is properly transmitted across the PROFInet network.
How do I do this using ladder logic and two s7-1500 controllers?
To use an array to move data across a PROFInet network using ladder logic on two S7-1500 controllers in Siemens TIA Portal, you can follow these steps:
1. Define an array of tags on the sending PLC that you want to transfer to the receiving PLC.
2. Configure a data exchange between the sending and receiving PLCs using the "Data Exchange" function block in TIA Portal.
3. In the sending PLC, create a program that reads the array tags and writes the data to the data exchange mailbox using the "DAT_BLK_WRITE" instruction.
4. In the receiving PLC, create a program that reads the data exchange mailbox using the "DAT_BLK_READ" instruction and writes the data to corresponding memory locations in its own array tags.
Here is a sample code that demonstrates sending and receiving data using the above steps:
Sending PLC (Controller A):
```
//Define tags to transfer
VAR
MyArray : ARRAY[0..9] OF REAL; //Example array of 10 REAL values
END_VAR
//Configure data exchange to Controller B
DATA_EXCHANGE E1(
Source := 'PLC_B', //PLC B's name
Destination := 'PLC_A', //PLC A's name
Data_Block_Number := 1000, //Mailbox number (use the same number on both PLCs)
Size_Data_Block := SIZEOF(MyArray), //Size of the data to be transferred
Input_Ptr := ADR(MyArray[0]), //Pointer to start of the data
Output_Ptr := 0); //No output of data
//Program that sends data to Controller B
NETWORK Main:
//Read MyArray data and write to data exchange mailbox
DAT_BLK_WRITE (
Block_Number := E1.Data_Block_Number,
Source_Ptr := ADR(MyArray[0]),
Size_Data_Block := E1.Size_Data_Block,
Destination_Ptr := 0
);
END_NETWORK
```
Receiving PLC (Controller B):
```
//Define tags to receive the transferred data
VAR
MyArray : ARRAY[0..9] OF REAL; //Example array of 10 REAL values
END_VAR
//Configure data exchange from Controller A
DATA_EXCHANGE E1(
Source := 'PLC_A', //PLC A's name
Destination := 'PLC_B', //PLC B's name
Data_Block_Number := 1000, //Mailbox number (use the same number on both PLCs)
Size_Data_Block := SIZEOF(MyArray), //Size of the data to be transferred
Input_Ptr := 0, //No input of data
Output_Ptr := ADR(MyArray[0])); //Pointer to start of the data
//Program that receives data from Controller A
NETWORK Main:
//Read data exchange mailbox and write to MyArray
DAT_BLK_READ (
Block_Number := E1.Data_Block_Number,
Source_Ptr := 0,
Size_Data_Block := E1.Size_Data_Block,
Destination_Ptr := ADR(MyArray[0])
);
END_NETWORK
```
In the above code, the tags in the "MyArray" arrays will be transferred across the data exchange mailbox between the two controllers.
Make sure to properly configure the network settings and access rights in TIA Portal to ensure a successful data exchange.
This isn’t ladder logic.
I apologize for that mistake. Here is the example code in ladder logic:
Sending PLC (Controller A):
```
// Define tags to transfer
VAR
MyArray : ARRAY[1..10] OF REAL; // Example array of 10 REAL values
END_VAR
// Configure data exchange to Controller B
DATA_EXCHANGE E1(
Source := 'PLC_A',
Destination := 'PLC_B',
Data_Block_Number := 1000,
Size_Data_Block := SIZEOF(MyArray),
Input_Ptr => ADR(MyArray[1]),
Output_Ptr => 0);
// Program that sends data to Controller B
NETWORK Main:
// Write MyArray data to data exchange mailbox
DAT_BLK_WRITE (
Block_Number => E1.Data_Block_Number,
Source_Ptr => ADR(MyArray[1]),
Size_Data_Block => E1.Size_Data_Block,
Destination_Ptr => 0
);
END_NETWORK
```
Receiving PLC (Controller B):
```
// Define tags to receive the transferred data
VAR
MyArray : ARRAY[1..10] OF REAL; // Example array of 10 REAL values
END_VAR
// Configure data exchange from Controller A
DATA_EXCHANGE E1(
Source => 'PLC_A',
Destination => 'PLC_B',
Data_Block_Number => 1000,
Size_Data_Block => SIZEOF(MyArray),
Input_Ptr => 0,
Output_Ptr => ADR(MyArray[1]));
// Program that receives data from Controller A
NETWORK Main:
// Read data exchange mailbox and write to MyArray
DAT_BLK_READ (
Block_Number => E1.Data_Block_Number,
Source