321 lines
10 KiB
Markdown
321 lines
10 KiB
Markdown
# Maselli Sensor to Siemens PLC Communication Implementation
|
|
|
|
## Introduction
|
|
|
|
This document provides an implementation guide for establishing communication between a Maselli sensor (which uses the ADAM protocol over RS485) and a Siemens S7-315 DP/PN PLC using a Waveshare RS232/485 TO WIFI ETH (B) gateway. This implementation handles the unidirectional communication where data flows from the sensor to the PLC.
|
|
|
|
## Maselli Protocol with ADAM Overview
|
|
|
|
As per the provided documentation, the Maselli sensor communicates with the following characteristics:
|
|
|
|
- **Maselli UR29**: RS485 with 115200 baud, 8N1 settings
|
|
|
|
- **Maselli UR62**: RS485 with 19200 baud, 8N1 settings
|
|
|
|
- **Communication Type**: Unidirectional (sensor sends data to PLC)
|
|
|
|
- **Data Format**: String with specific format:
|
|
|
|
```
|
|
# XX XX.YYY CkCk Cr
|
|
```
|
|
|
|
Where:
|
|
|
|
- `#` is the start character
|
|
- `XX` is the ADAM address (2 chars)
|
|
- `XX.YYY` is the Brix or Temperature value in mA (6 chars)
|
|
- `CkCk` is the checksum (2 chars)
|
|
- `Cr` is the carriage return
|
|
- **Value Range Example**:
|
|
|
|
- 4 mA corresponds to Low Brix value (e.g., 0 Brix)
|
|
- 20 mA corresponds to High Brix value (e.g., 80 Brix)
|
|
|
|
## SCL Implementation
|
|
|
|
The following SCL code provides a complete implementation for handling this communication. The implementation consists of multiple parts:
|
|
|
|
1. A function block for managing TCP/IP communication with the gateway
|
|
2. Functions for parsing the Maselli protocol string
|
|
3. Functions for scaling the mA value to the appropriate Brix value
|
|
4. Configuration functions for the TCP connection
|
|
|
|
### Main Function Block
|
|
|
|
```pascal
|
|
FUNCTION_BLOCK "Maselli_Comm"
|
|
VAR_INPUT
|
|
xExecute : BOOL; // Trigger to initiate connection
|
|
tConnectionID : TCON_IP_v4; // TCP connection parameters
|
|
END_VAR
|
|
|
|
VAR_OUTPUT
|
|
xConnected : BOOL; // Connection status
|
|
xError : BOOL; // Communication error
|
|
wErrorID : WORD; // Error code
|
|
rBrixValue : REAL; // Calculated Brix value
|
|
rTempValue : REAL; // Calculated Temperature value (if applicable)
|
|
rCurrentmA : REAL; // Received mA value
|
|
END_VAR
|
|
|
|
VAR
|
|
// TCP communication variables
|
|
fbTCON : TCON; // FB for TCP connection
|
|
fbTRCV : TRCV; // FB for TCP reception
|
|
xTCONExecute : BOOL;
|
|
xTRCVExecute : BOOL;
|
|
wTCONID : WORD := 1; // Connection ID
|
|
|
|
// Buffer and processing variables
|
|
aRxBuffer : ARRAY[0..255] OF BYTE; // Reception buffer
|
|
iRxLength : INT; // Received length
|
|
sRxString : STRING[255]; // Reception string
|
|
sParsedValue : STRING[6]; // Extracted value as string (XX.YYY)
|
|
|
|
// Parsing variables
|
|
iState : INT := 0; // Parsing state
|
|
xNewDataReceived : BOOL := FALSE; // New data flag
|
|
|
|
// Scaling variables
|
|
rLowBrix : REAL := 0.0; // Low Brix value (4mA)
|
|
rHighBrix : REAL := 80.0; // High Brix value (20mA)
|
|
END_VAR
|
|
|
|
VAR CONSTANT
|
|
START_CHAR : BYTE := 16#23; // '#' in ASCII
|
|
END_VAR
|
|
|
|
BEGIN
|
|
// ---- TCP Connection Management ----
|
|
IF xExecute AND NOT xConnected THEN
|
|
xTCONExecute := TRUE;
|
|
END_IF;
|
|
|
|
// Establish connection
|
|
fbTCON(
|
|
EN := TRUE,
|
|
ENO => ,
|
|
REQ := xTCONExecute,
|
|
ID := wTCONID,
|
|
CONNECT := tConnectionID,
|
|
DONE => xConnected,
|
|
BUSY => ,
|
|
ERROR => xError,
|
|
STATUS => wErrorID
|
|
);
|
|
|
|
// Reset connection trigger
|
|
IF xConnected OR xError THEN
|
|
xTCONExecute := FALSE;
|
|
END_IF;
|
|
|
|
// ---- Data Reception ----
|
|
IF xConnected THEN
|
|
xTRCVExecute := TRUE;
|
|
|
|
// Receive data
|
|
fbTRCV(
|
|
EN := TRUE,
|
|
ENO => ,
|
|
REQ := xTRCVExecute,
|
|
ID := wTCONID,
|
|
LEN := 0, // Adhoc mode (receives whatever is available)
|
|
DATA := aRxBuffer,
|
|
RCVD_LEN => iRxLength,
|
|
DONE => xNewDataReceived,
|
|
BUSY => ,
|
|
ERROR => xError,
|
|
STATUS => wErrorID
|
|
);
|
|
|
|
// Process received data
|
|
IF xNewDataReceived AND iRxLength > 0 THEN
|
|
// Convert data to string for processing
|
|
sRxString := '';
|
|
FOR i := 0 TO iRxLength-1 DO
|
|
sRxString := CONCAT(IN1 := sRxString,
|
|
IN2 := CHR(IN := aRxBuffer[i]));
|
|
END_FOR;
|
|
|
|
// Process Maselli/ADAM protocol
|
|
ParseMaselliString(sRxString);
|
|
|
|
// Calculate Brix value based on mA value (linear scale)
|
|
rBrixValue := LinearScale(rCurrentmA, 4.0, 20.0, rLowBrix, rHighBrix);
|
|
|
|
// Reset flag
|
|
xNewDataReceived := FALSE;
|
|
END_IF;
|
|
END_IF;
|
|
END_FUNCTION_BLOCK
|
|
```
|
|
|
|
### Parsing Function
|
|
|
|
```pascal
|
|
// Function to process the received Maselli/ADAM string
|
|
FUNCTION "ParseMaselliString" : VOID
|
|
VAR_INPUT
|
|
sInputString : STRING;
|
|
END_VAR
|
|
VAR_TEMP
|
|
sCurrentChar : STRING(1);
|
|
iPos : INT := 0;
|
|
iParseState : INT := 0; // 0:Waiting for #, 1:Reading addr, 2:Reading value, 3:Reading checksum
|
|
sAddrStr : STRING(2);
|
|
sValueStr : STRING(6);
|
|
sChecksumStr : STRING(2);
|
|
END_VAR
|
|
BEGIN
|
|
// Reset variables
|
|
sAddrStr := '';
|
|
sValueStr := '';
|
|
sChecksumStr := '';
|
|
|
|
// Parse the string character by character
|
|
FOR iPos := 0 TO LEN(sInputString) - 1 DO
|
|
sCurrentChar := MID(IN := sInputString, L := 1, P := iPos + 1);
|
|
|
|
CASE iParseState OF
|
|
0: // Waiting for start character '#'
|
|
IF sCurrentChar = '#' THEN
|
|
iParseState := 1;
|
|
END_IF;
|
|
|
|
1: // Reading ADAM address (2 characters)
|
|
sAddrStr := CONCAT(IN1 := sAddrStr, IN2 := sCurrentChar);
|
|
IF LEN(sAddrStr) = 2 THEN
|
|
iParseState := 2;
|
|
END_IF;
|
|
|
|
2: // Reading mA value (6 characters, format XX.YYY)
|
|
sValueStr := CONCAT(IN1 := sValueStr, IN2 := sCurrentChar);
|
|
IF LEN(sValueStr) = 6 THEN
|
|
iParseState := 3;
|
|
// Convert string to real value
|
|
#rCurrentmA := STRING_TO_REAL(sValueStr);
|
|
END_IF;
|
|
|
|
3: // Reading checksum (2 characters)
|
|
sChecksumStr := CONCAT(IN1 := sChecksumStr, IN2 := sCurrentChar);
|
|
// Checksum validation not implemented in this simplified example
|
|
END_CASE;
|
|
END_FOR;
|
|
END_FUNCTION
|
|
```
|
|
|
|
### Scaling Function
|
|
|
|
```pascal
|
|
// Function to linearly scale the mA value to Brix
|
|
FUNCTION "LinearScale" : REAL
|
|
VAR_INPUT
|
|
rInput : REAL; // Value to scale (mA)
|
|
rInMin : REAL; // Input minimum (4mA)
|
|
rInMax : REAL; // Input maximum (20mA)
|
|
rOutMin : REAL; // Output minimum (0 Brix)
|
|
rOutMax : REAL; // Output maximum (80 Brix)
|
|
END_VAR
|
|
BEGIN
|
|
// Linear scaling formula
|
|
#LinearScale := (rInput - rInMin) * (rOutMax - rOutMin) / (rInMax - rInMin) + rOutMin;
|
|
|
|
// Ensure result is within limits
|
|
IF #LinearScale < rOutMin THEN
|
|
#LinearScale := rOutMin;
|
|
ELSIF #LinearScale > rOutMax THEN
|
|
#LinearScale := rOutMax;
|
|
END_IF;
|
|
END_FUNCTION
|
|
```
|
|
|
|
### Main Application Block
|
|
|
|
```pascal
|
|
// Main application block
|
|
ORGANIZATION_BLOCK "OB1"
|
|
VAR_TEMP
|
|
// Temporary variables
|
|
END_VAR
|
|
BEGIN
|
|
// Configure TCP connection
|
|
"ConfigureTCPConnection"();
|
|
|
|
// Process Maselli data
|
|
"FB_Maselli_Communications"(
|
|
xExecute := TRUE,
|
|
tConnectionID := "g_tConnection"
|
|
);
|
|
|
|
// Additional code to use Brix values can be added here
|
|
END_ORGANIZATION_BLOCK
|
|
```
|
|
|
|
### Connection Configuration Function
|
|
|
|
```pascal
|
|
// Function to configure TCP connection parameters
|
|
FUNCTION "ConfigureTCPConnection" : VOID
|
|
VAR_GLOBAL
|
|
g_tConnection : TCON_IP_v4; // Global variable for connection parameters
|
|
END_VAR
|
|
BEGIN
|
|
// Configure TCP connection parameters
|
|
g_tConnection.InterfaceId := 64; // Ethernet interface ID (verify in hardware)
|
|
g_tConnection.ID := 1; // Connection ID
|
|
g_tConnection.ConnectionType := 11; // Connection type: TCP
|
|
g_tConnection.ActiveEstablished := TRUE; // PLC initiates connection
|
|
|
|
// IP and port of Waveshare gateway
|
|
g_tConnection.RemoteAddress.ADDR[1] := 10; // IP Address: 192.168.x.x
|
|
g_tConnection.RemoteAddress.ADDR[2] := 1; // Adjust according to gateway IP
|
|
g_tConnection.RemoteAddress.ADDR[3] := 33; // Adjust according to gateway IP
|
|
g_tConnection.RemoteAddress.ADDR[4] := 18; // Adjust according to gateway IP
|
|
g_tConnection.RemotePort := 8899; // Default gateway port
|
|
|
|
// Local port for TCP connection
|
|
g_tConnection.LocalPort := 2000; // Arbitrary local port
|
|
END_FUNCTION
|
|
```
|
|
|
|
## Configuration Guide
|
|
|
|
To implement this solution, follow these steps:
|
|
|
|
### 1. Configure the Waveshare Gateway
|
|
|
|
Configure the Waveshare RS232/485 TO WIFI ETH (B) gateway in transparent transmission mode with these parameters:
|
|
|
|
- **For UR29 sensor**:
|
|
|
|
- RS485: 115200 baud, 8N1
|
|
- TCP Server mode (recommended)
|
|
- Fixed IP address on your network
|
|
- **For UR62 sensor**:
|
|
|
|
- RS485: 19200 baud, 8N1
|
|
- TCP Server mode (recommended)
|
|
- Fixed IP address on your network
|
|
|
|
### 2. PLC Configuration
|
|
|
|
- Import the SCL code into your TIA Portal project
|
|
- Adjust the IP address settings in the `ConfigureTCPConnection` function to match your gateway's IP
|
|
- Modify the `rLowBrix` and `rHighBrix` values according to your specific application requirements
|
|
- Configure the Ethernet port of the S7-315 PLC to be on the same subnet as the gateway
|
|
|
|
### 3. Verification
|
|
|
|
After implementing the code:
|
|
|
|
- Monitor the `xConnected` output to verify the connection status
|
|
- Check the `rBrixValue` output to see the converted Brix values
|
|
- Use the `xError` and `wErrorID` outputs for troubleshooting if connection issues occur
|
|
|
|
## Additional Notes
|
|
|
|
- This implementation focuses on handling the reception of data in the specified Maselli/ADAM format
|
|
- The checksum validation is not implemented in this example but could be added for improved reliability
|
|
- For optimal performance, ensure the network connection between the PLC and the gateway is stable
|
|
- Consider adding watchdog functionality to detect communication failures |