IronPLC

https://www.ironplc.com
Admin
IronPLC is an open-source compiler, runtime, and Visual Studio Code editor extension for writing and...
Tokens:96,818
Snippets:1,292
Trust Score:7.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example Configuration

Source: https://www.ironplc.com/reference/language/pous/configuration.html

Illustrates a typical configuration assigning a program to a resource and task.

```iec61131-3
CONFIGURATION DefaultConfig
    RESOURCE DefaultResource ON PLC
        TASK MainTask(INTERVAL := T#20ms, PRIORITY := 1);
        PROGRAM main WITH MainTask : MainProgram;
    END_RESOURCE
END_CONFIGURATION

```

--------------------------------

### Runtime Output Example

Source: https://www.ironplc.com/quickstart/configuring.html

Observe the real-time variable updates in the IronPLC Run output panel. This example shows the state of variables after the program has been running, including timer status.

```text
Scan cycle: 10
---
  Button : BOOL = FALSE
  Buzzer : BOOL = TRUE
  PulseTimer.IN : BOOL = TRUE
  PulseTimer.PT : TIME = T#500ms
  PulseTimer.Q : BOOL = TRUE
  PulseTimer.ET : TIME = T#1000ms

```

--------------------------------

### Example FUNCTION: Square

Source: https://www.ironplc.com/reference/language/pous/function.html

This example demonstrates defining a simple 'Square' function that takes a DINT input and returns its square. It includes VAR_INPUT for parameters and assigns the result to the function name.

```IEC 61131-3
FUNCTION Square : DINT
    VAR_INPUT
        x : DINT;
    END_VAR

    Square := x * x;
END_FUNCTION
```

--------------------------------

### Arithmetic Example with ADD

Source: https://www.ironplc.com/reference/standard-library/functions/add.html

Demonstrates the use of arithmetic operations, including addition, within a PLC program. This example increments a counter and doubles its value in each scan cycle.

```IEC 61131-3
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
  doubled := count * 2;
END_PROGRAM

```

--------------------------------

### Resource with Tasks and Programs

Source: https://www.ironplc.com/reference/language/pous/task.html

Example of how to declare multiple tasks with different intervals and priorities within a resource, and associate programs with these tasks using the WITH keyword.

```iec61131-3
RESOURCE DefaultResource ON PLC
    TASK MainTask(INTERVAL := T#20ms, PRIORITY := 1);
    TASK FastTask(INTERVAL := T#5ms, PRIORITY := 0);

    PROGRAM main WITH MainTask : MainProgram;
END_RESOURCE

```

--------------------------------

### FIND Function Usage Example

Source: https://www.ironplc.com/reference/standard-library/functions/find.html

This example demonstrates how to use the FIND function within a program. It shows how to assign the result to a variable and implies the function's behavior with string inputs.

```iecst
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR
(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;

doubled := count * 2;
END_PROGRAM

```

--------------------------------

### Valid Structured Text Program Example

Source: https://www.ironplc.com/reference/compiler/problems/P9002.html

This example demonstrates a basic valid Structured Text program. Ensure your source files contain code similar to this to avoid P9002.

```IEC 61131-3
(* This is a valid Structured Text program *)
FUNCTION_BLOCK Example
VAR_INPUT
    Input1 : BOOL;
END_VAR
VAR_OUTPUT
    Output1 : BOOL;
END_VAR

Output1 := Input1;
END_FUNCTION_BLOCK

```

--------------------------------

### Install Specific IronPLC Version with Install Script (Linux)

Source: https://www.ironplc.com/quickstart/installation.html

Use this command to install a specific version of the IronPLC CLI on Linux by specifying the desired version in the IRONPLC_VERSION environment variable.

```bash
curl -fsSL https://www.ironplc.com/install.sh | IRONPLC_VERSION=v0.201.0 sh
```

--------------------------------

### RESOURCE Example

Source: https://www.ironplc.com/reference/language/pous/resource.html

Illustrates how to declare a resource named 'DefaultResource' on a 'PLC' type, associating 'MainProgram' with 'MainTask' and 'FastProgram' with 'FastTask'. Tasks are defined with specific intervals and priorities.

```iec61131-3
RESOURCE DefaultResource ON PLC
    TASK MainTask(INTERVAL := T#20ms, PRIORITY := 1);
    TASK FastTask(INTERVAL := T#5ms, PRIORITY := 0);

    PROGRAM main WITH MainTask : MainProgram;
    PROGRAM fast WITH FastTask : FastProgram;
END_RESOURCE

```

--------------------------------

### SINT Variable Usage Example

Source: https://www.ironplc.com/reference/language/data-types/elementary/sint.html

An example program demonstrating the use of integer variables, including incrementing a counter and doubling its value. This program runs in cycles, updating variables between each cycle.

```IEC 61131-3
PROGRAM main
VAR
    count : INT;
    doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;

END_PROGRAM
```

--------------------------------

### Install IronPLC CLI with Homebrew (macOS)

Source: https://www.ironplc.com/quickstart/installation.html

Use this command to install the IronPLC CLI on macOS if you have Homebrew installed. It ensures you have the latest version and adds it to your PATH.

```bash
brew tap ironplc/tap
brew install ironplc
```

--------------------------------

### Compile After Copying File (Alternative Fix)

Source: https://www.ironplc.com/reference/compiler/problems/P6005.html

This example demonstrates an alternative solution to the P6005 error by copying the target file to a new location without using symbolic links, then compiling the copied file.

```bash
# Copy the file instead of linking
cp /path/to/actual/program.st /path/to/program_copy.st
ironplcc check /path/to/program_copy.st
```

--------------------------------

### Compile Using Actual File Path (Fix)

Source: https://www.ironplc.com/reference/compiler/problems/P6005.html

This example shows the correct way to compile a file by using its actual, direct path, bypassing the symbolic link. This resolves the P6005 error.

```bash
# Use the actual file path instead
ironplcc check /path/to/actual/program.st
```

--------------------------------

### Boolean Logic Example

Source: https://www.ironplc.com/reference/language/data-types/elementary/bool.html

This example demonstrates a simple program that increments a counter in each scan cycle. The counter variable 'count' is updated, and 'doubled' shows its doubled value. This illustrates how boolean logic and arithmetic can be used in a program.

```iec61131-3
PROGRAM main
VAR
    count : INT;
    doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;
END_PROGRAM

```

--------------------------------

### project_io

Source: https://www.ironplc.com/reference/mcp/tools.html

Lists the inputs the caller can drive and the outputs the caller can observe. This is the right tool to call before planning an execution run — for example, to decide which variables to supply as stimuli or which to trace.

```APIDOC
## project_io

### Description
Lists the inputs the caller can drive and the outputs the caller can observe. This is the right tool to call before planning an execution run — for example, to decide which variables to supply as stimuli or which to trace.

### Inputs:
`sources`, `options`.

### Returns:
an object with `ok`, `inputs`, `outputs`, and `diagnostics`.
```

--------------------------------

### Arithmetic Operation Example

Source: https://www.ironplc.com/reference/standard-library/functions/sub.html

Illustrates a basic arithmetic operation within a PLC program. This example shows incrementing a counter and doubling its value.

```iec61131-3
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;

doubled := count * 2;

END_PROGRAM

```

--------------------------------

### Bit Access Example

Source: https://www.ironplc.com/reference/language/data-types/elementary/byte.html

Illustrates how to access individual bits of a BYTE variable using `.n` or `.%Xn` syntax. Valid indices are 0 to 7.

```IEC 61131-3
flags.3
```

```IEC 61131-3
flags.%X3
```

--------------------------------

### Basic Array Example

Source: https://www.ironplc.com/reference/language/data-types/derived/array-types.html

Demonstrates a simple program structure with variable declarations, including an integer variable 'count'. This example is part of the IronPLC Playground and shows how variables maintain their values between scan cycles.

```IEC 61131-3
PROGRAM main
VAR
    count : INT;
    doubled : INT;
END_VAR
(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;
END_PROGRAM
```

--------------------------------

### Compile with Symbolic Link (Error)

Source: https://www.ironplc.com/reference/compiler/problems/P6005.html

This example demonstrates how creating a symbolic link and then attempting to compile the linked file triggers the P6005 error. Use the actual file path instead of a symlink.

```bash
# Create a symbolic link to a Structured Text file
ln -s /path/to/actual/program.st /path/to/link.st

# This will generate error P6005:
ironplcc check /path/to/link.st
```

--------------------------------

### list_options

Source: https://www.ironplc.com/reference/mcp/tools.html

Enumerates the dialects and feature flags accepted in the `options` object of the source-accepting tools. Call this once at the start of a session to learn what your build of **ironplcmcp** supports; the set of flags evolves with the compiler.

```APIDOC
## list_options

### Description
Enumerates the dialects and feature flags accepted in the `options` object of the source-accepting tools. Call this once at the start of a session to learn what your build of **ironplcmcp** supports; the set of flags evolves with the compiler.

### Inputs:
none.

### Returns:
an object listing each dialect and each feature flag with its option key and default value.
```

--------------------------------

### Examples of IronPLC Commands Causing P6004

Source: https://www.ironplc.com/reference/compiler/problems/P6004.html

These commands demonstrate scenarios that would trigger the P6004 error due to file accessibility issues. Use these examples to understand common failure cases.

```bash
# Examples that would cause this error:
ironplcc check nonexistent_file.st             # File doesn't exist
ironplcc check /root/private_file.st           # Permission denied
ironplcc check locked_file.st                  # File locked by another process
```

--------------------------------

### Variable Retention Qualifiers Example

Source: https://www.ironplc.com/reference/language/variables/retention.html

Demonstrates the usage of RETAIN, CONSTANT, and default variable qualifiers in IEC 61131-3.

```iec61131-3
PROGRAM main
    VAR RETAIN
        run_hours : DINT := 0;
    END_VAR
    VAR CONSTANT
        MAX_TEMP : INT := 150;
    END_VAR
    VAR
        current_temp : INT;
    END_VAR

    run_hours := run_hours + 1;
END_PROGRAM

```

--------------------------------

### Bit Access Syntax Examples

Source: https://www.ironplc.com/reference/language/structured-text/bit-access.html

Demonstrates the different ways to access a single bit of a variable using the short form syntax. This applies to simple variables, array elements, and structure fields.

```IEC 61131-3
my_byte.3              (* simple variable *)
my_array[i].3          (* array element *)
my_record.field.3      (* structure field *)
```

--------------------------------

### Incorrect PLCopen XML Root Element

Source: https://www.ironplc.com/reference/compiler/problems/P0007.html

This example shows an XML structure with a root element of `<configuration>`, which is incorrect for PLCopen schema. The compiler expects the root element to be `<project>`.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration xmlns="http://www.plcopen.org/xml/tc6_0201">
  <!-- Wrong root element - should be <project> -->
</configuration>
```

--------------------------------

### Using Basic Type as Alternative

Source: https://www.ironplc.com/reference/compiler/problems/P9001.html

This example shows how to resolve error P9001 by replacing the unimplemented TON type with a basic BOOL type, offering an alternative approach until the standard type is implemented.

```IEC 61131-3
FUNCTION_BLOCK DUMMY
VAR_INPUT
    name : BOOL;  (* Use a basic type instead *)
END_VAR
END_FUNCTION_BLOCK

```

--------------------------------

### Fixing P4020 Error by Adding PROGRAM Declaration

Source: https://www.ironplc.com/reference/compiler/problems/P4020.html

This example shows how to resolve the P4020 error by adding a PROGRAM declaration to the source code. The PROGRAM serves as the entry point for the compiler.

```iec61131-3
FUNCTION_BLOCK my_fb
VAR
    x : INT;
END_VAR
    x := 1;
END_FUNCTION_BLOCK

PROGRAM main
VAR
    fb_inst : my_fb;
END_VAR
    fb_inst();
END_PROGRAM

```

--------------------------------

### Fix for P4032: Initialized Constant in Type Parameter

Source: https://www.ironplc.com/reference/compiler/problems/P4032.html

This code shows the corrected version of the previous example, where the constant 'MAX_LEN' is initialized with a value. This resolves the P4032 error.

```iec61131
VAR_GLOBAL CONSTANT
    MAX_LEN : INT := 100;
END_VAR

```

--------------------------------

### Malformed XML Example

Source: https://www.ironplc.com/reference/compiler/problems/P0006.html

This snippet demonstrates an incomplete XML tag, leading to a malformed XML error. Ensure all tags are properly closed and attributes are correctly formatted.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.plcopen.org/xml/tc6_0201">
  <fileHeader companyName="Test" productName="Test"
  <!-- Missing closing > and rest of document -->

```

--------------------------------

### P4032 Error Example: Uninitialized Constant in Type Parameter

Source: https://www.ironplc.com/reference/compiler/problems/P4032.html

This code demonstrates the P4032 error where a constant 'MAX_LEN' is used for a STRING length but is not initialized. Provide an initializer to fix this.

```iec61131
VAR_GLOBAL CONSTANT
    MAX_LEN : INT;
END_VAR

FUNCTION_BLOCK MyFB
VAR_INPUT
    name : STRING[MAX_LEN];
END_VAR
END_FUNCTION_BLOCK

```

--------------------------------

### Examples of Problematic Paths for P6001 Error

Source: https://www.ironplc.com/reference/compiler/problems/P6001.html

Demonstrates various invalid file paths that can trigger the P6001 compiler error. These include paths with null characters, non-existent network locations, and restricted directories.

```bash
# Example of problematic paths that might cause this error:
ironplcc check "/invalid\0path/file.st"        # Invalid null character
ironplcc check "//server/missing/file.st"      # Non-existent network path
ironplcc check "/root/restricted/file.st"      # Permission denied

```

--------------------------------

### TP Pulse Timer Example

Source: https://www.ironplc.com/reference/standard-library/function-blocks/tp.html

This example demonstrates triggering a 1-second pulse using the TP function block. The 'active' variable becomes TRUE when the pulse starts.

```IEC 61131-3
PROGRAM main
VAR
    pulseTimer : TP;
    trigger : BOOL;
    active : BOOL;
    elapsedTime : TIME;
END_VAR

(* On the first scan, trigger is TRUE, starting the pulse. *)
IF trigger THEN
    pulseTimer(IN := TRUE, PT := T#1s);
ELSE
    pulseTimer(IN := FALSE, PT := T#1s);
END_IF

active := pulseTimer.Q;
elapsedTime := pulseTimer.ET;

(* To simulate a single trigger on the first scan: *) 
(* trigger := NOT trigger; *)
```

--------------------------------

### Configure IronPLC Settings in settings.json

Source: https://www.ironplc.com/reference/editor/settings.html

Set IronPLC extension configurations directly in your settings.json file. This example shows how to set the compiler path, log level, log file, and dialect.

```json
{
  "ironplc.path": "/custom/path/to/ironplcc",
  "ironplc.logLevel": "DEBUG",
  "ironplc.logFile": "/tmp/ironplc-debug.log",
  "ironplc.dialect": "rusty"
}

```

--------------------------------

### Correct Reference Assignment

Source: https://www.ironplc.com/reference/compiler/problems/P2032.html

This example shows the correct way to assign a reference. Ensure the reference type 'REF_TO INT' exactly matches the target variable type 'INT'.

```IEC 61131-3
PROGRAM Main
    VAR
        x : INT;
        y : REF_TO INT;
    END_VAR

    y := REF(x);  (* Correct: REF_TO INT matches INT variable *)
END_PROGRAM

```

--------------------------------

### Update IronPLC CLI with Install Script (macOS/Linux)

Source: https://www.ironplc.com/how-to-guides/update.html

Re-run the install script to update IronPLC if it was installed using the provided script on macOS or Linux.

```bash
curl -fsSL https://www.ironplc.com/install.sh | sh
```

--------------------------------

### Create Hello World Program

Source: https://www.ironplc.com/reference/compiler/overview.html

Create an IEC 61131-3 program file named 'main.st' with a simple logic for a button and buzzer.

```iec61131-3
PROGRAM main
   VAR
      Button AT %IX1: BOOL;
      Buzzer AT %QX1: BOOL;
   END_VAR

   Buzzer := NOT Button;

END_PROGRAM

CONFIGURATION config
   RESOURCE res ON PLC
      TASK plc_task(INTERVAL := T#100ms, PRIORITY := 1);
      PROGRAM plc_task_instance WITH plc_task : main;
   END_RESOURCE
END_CONFIGURATION
```

--------------------------------

### Recommended Project Layout

Source: https://www.ironplc.com/how-to-guides/getting-started/structure-a-multi-file-project.html

A flat structure for small to medium projects, organizing configuration, main program, utilities, and global variables into separate files.

```text
my-project/
├── config.st        # Configuration, resource, and task definitions
├── main.st          # Main program
├── utilities.st     # Reusable functions and function blocks
└── globals.st       # Global variable lists (if needed)

```

--------------------------------

### TRUNC Function Usage Example

Source: https://www.ironplc.com/reference/standard-library/functions/trunc.html

Example demonstrating the TRUNC function's behavior. The return type is determined by the variable being assigned to.

```APIDOC
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

count := count + 1;
doubled := count * 2;
END_PROGRAM
```

--------------------------------

### MID Function Signature and Usage

Source: https://www.ironplc.com/reference/standard-library/functions/mid.html

Provides the function signature, input parameters, output, and a detailed description of the MID function's behavior. It explains how to extract a substring based on starting position and length.

```APIDOC
## MID Function

### Description
`MID(IN, L, P)` returns _L_ characters from _IN_ starting at position _P_. Positions are 1-based: the first character is at position 1.

### Signature
```
FUNCTION MID : ANY_STRING
  VAR_INPUT
    IN : ANY_STRING;
    L  : ANY_INT;
    P  : ANY_INT;
  END_VAR
END_FUNCTION
```

The return type matches the type of _IN_. `MID` accepts `STRING` for _IN_ ; _L_ and _P_ are `INT`.

### Inputs

| Name | Type | Description |
|---|---|---|
| `IN` | `ANY_STRING` | The source string. |
| `L` | `INT` | Number of characters to extract. |
| `P` | `INT` | Starting position (1-based). |

### Outputs

| Name | Type | Description |
|---|---|---|
| Return value | `ANY_STRING` | L characters from IN starting at position P. Same type as IN. |
```

--------------------------------

### Create Project Directory

Source: https://www.ironplc.com/reference/compiler/overview.html

Use these commands to create a new directory for your IEC 61131-3 project and navigate into it.

```bash
mkdir ~/ironplc-hello-world
cd ~/ironplc-hello-world

```

--------------------------------

### Valid Structured Text file example

Source: https://www.ironplc.com/reference/compiler/problems/P6006.html

An example of a Structured Text file that is properly encoded with UTF-8. Ensure your source files adhere to this structure and encoding.

```iecst
(* This file should be saved with UTF-8 encoding *)
FUNCTION_BLOCK ValidEncoding
VAR_INPUT
    InputData : BOOL;
END_VAR
VAR_OUTPUT
    OutputData : BOOL;
END_VAR

OutputData := InputData;
END_FUNCTION_BLOCK

```

--------------------------------

### Create Project Directory - Shell

Source: https://www.ironplc.com/quickstart/helloworld.html

Use these shell commands to create a new directory for your project and navigate into it.

```shell
mkdir doorbell
cd doorbell

```

--------------------------------

### Show available dialects and their features

Source: https://www.ironplc.com/reference/compiler/ironplcc.html

List all available compiler dialects and their associated features using the `dialects` command.

```bash
ironplcc dialects
```

--------------------------------

### Valid IEC 61131-3 Function Block Example

Source: https://www.ironplc.com/reference/compiler/problems/P6004.html

This is an example of a syntactically correct and readable IEC 61131-3 Function Block. It serves as a contrast to files that might cause the P6004 error.

```iec61131-3
(* Example of a valid file that can be read *)
FUNCTION_BLOCK ReadableFile
VAR_INPUT
    InputSignal : BOOL;
END_VAR
VAR_OUTPUT
    OutputSignal : BOOL;
END_VAR

OutputSignal := InputSignal;
END_FUNCTION_BLOCK
```

--------------------------------

### Verify File Existence and Permissions

Source: https://www.ironplc.com/reference/runtime/problems/V6001.html

Use `ls -l` to check if the bytecode file exists and `chmod +r` to ensure read permissions are set.

```bash
# Verify the file exists
ls -l program.iplc
```

```bash
# Check permissions
chmod +r program.iplc
```

--------------------------------

### ATAN Function Example

Source: https://www.ironplc.com/reference/standard-library/functions/atan.html

Illustrates the usage of the ATAN function within a simple program. Note: This example is part of a larger interactive playground and may require execution context to fully understand.

```IEC 61131-3
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;
END_PROGRAM

```

--------------------------------

### Complete Application with Configuration - ST

Source: https://www.ironplc.com/quickstart/configuring.html

Add a configuration block to schedule the main program execution. This defines resources and tasks, specifying the interval and priority for running the program cyclically.

```iecst
PROGRAM main
   VAR
      Button : BOOL;
      Buzzer : BOOL;
      PulseTimer : TON;
   END_VAR

   PulseTimer(IN := NOT Button, PT := T#500ms);
   Buzzer := PulseTimer.Q;

END_PROGRAM

CONFIGURATION config
   RESOURCE res ON PLC
      TASK plc_task(INTERVAL := T#100ms, PRIORITY := 1);
      PROGRAM plc_task_instance WITH plc_task : main;
   END_RESOURCE
END_CONFIGURATION

```

--------------------------------

### Add Star-Delta Starter to PLC Program

Source: https://www.ironplc.com/how-to-guides/ai-agents/write-plc-programs-with-an-ai-agent.html

Use this prompt to instruct the AI agent to add a star-delta starter with a 5-second changeover timer using the TON standard library block. Ensure Star, Delta, and Main contactors are included.

```text
Add a star-delta starter with a 5-second changeover timer
using TON. Add Star, Delta, and Main contactors.


```

--------------------------------

### Basic Ladder Diagram Rung Structure

Source: https://www.ironplc.com/reference/language/ladder-diagram/rungs.html

Illustrates a simple rung with a start button, a hold contact, and a motor output coil. Power flows from left to right, activating the coil only if the start button is pressed and the hold contact is maintained.

```ladder-diagram
|    start_button     motor_output    |
|---| |---+---( )---|
|             |
|    hold     |
|---| |---|
```

--------------------------------

### Correct PLCopen XML Structure

Source: https://www.ironplc.com/reference/compiler/problems/P0007.html

This example demonstrates a correct PLCopen XML structure adhering to the TC6 v2.01 schema. It includes the required `<project>` root element and essential child elements like `<fileHeader>`, `<contentHeader>`, and `<types>`.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://www.plcopen.org/xml/tc6_0201">
  <fileHeader companyName="Company" productName="Product" productVersion="1.0" creationDateTime="2024-01-01T00:00:00"/>
  <contentHeader name="ProjectName">
    <coordinateInfo>
      <fbd><scaling x="1" y="1"/></fbd>
      <ld><scaling x="1" y="1"/></ld>
      <sfc><scaling x="1" y="1"/></sfc>
    </coordinateInfo>
  </contentHeader>
  <types>
    <dataTypes/>
    <pous/>
  </types>
</project>
```

--------------------------------

### MAX Function Usage Example

Source: https://www.ironplc.com/reference/standard-library/functions/max.html

Demonstrates the usage of the MAX function within a simple program. The example shows how to increment a counter and use it with the MAX function, although the MAX function itself is not directly called in this specific snippet, it's implied by the context of arithmetic operations.

```iecst
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR
(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;
END_PROGRAM

```

--------------------------------

### LREAL Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/lreal.html

Examples of valid LREAL literals, including positive, negative, and scientific notation.

```IEC 61131-3
LREAL#3.14159265358979
LREAL#-1.0
LREAL#1.0E+100
```

--------------------------------

### One POU per File Project Layout

Source: https://www.ironplc.com/how-to-guides/getting-started/structure-a-multi-file-project.html

For larger projects, consider placing each program, function, or function block into its own file, named after the POU for better organization.

```text
my-project/
├── config.st
├── main.st
├── motor_control.st        # FUNCTION_BLOCK MotorControl
├── temperature_monitor.st  # FUNCTION_BLOCK TemperatureMonitor
└── clamp.st                # FUNCTION Clamp

```

--------------------------------

### LINT Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/lint.html

Examples of how to define LINT literals in IronPLC, including positive, negative, and hexadecimal values.

```iec61131-3
LINT#42
LINT#-100000000
LINT#16#FFFFFFFF
```

--------------------------------

### Update IronPLC CLI with Homebrew (macOS)

Source: https://www.ironplc.com/how-to-guides/update.html

Use this command to update IronPLC if it was installed via Homebrew on macOS.

```bash
brew update
brew upgrade ironplc
```

--------------------------------

### project_manifest

Source: https://www.ironplc.com/reference/mcp/tools.html

Flat summary of what is declared across the supplied sources: file names, program / function / function-block names, and user-defined types grouped by kind (enumerations, structures, arrays, subranges, aliases, strings, references). Use this to orient yourself in an unfamiliar project before calling `symbols` or a more targeted context tool.

```APIDOC
## project_manifest

### Description
Flat summary of what is declared across the supplied sources: file names, program / function / function-block names, and user-defined types grouped by kind (enumerations, structures, arrays, subranges, aliases, strings, references). Use this to orient yourself in an unfamiliar project before calling `symbols` or a more targeted context tool.

### Inputs:
`sources`, `options`.

### Returns:
an object with `ok`, `files`, `programs`, `functions`, `function_blocks`, grouped `types`, and `diagnostics`.
```

--------------------------------

### DELETE Function Signature and Usage

Source: https://www.ironplc.com/reference/standard-library/functions/delete.html

Describes the signature, inputs, outputs, and provides a description and example for the DELETE function.

```APIDOC
## DELETE

Deletes characters from a string.

### Signature

```
FUNCTION DELETE : ANY_STRING
  VAR_INPUT
    IN : ANY_STRING;
    L  : ANY_INT;
    P  : ANY_INT;
  END_VAR
END_FUNCTION
```

The return type matches the type of _IN_. `DELETE` accepts `STRING` for _IN_ ; _L_ and _P_ are `INT`.

### Inputs

Name | Type | Description
---|---|---
`IN` | `ANY_STRING` | The source string.
`L` | `INT` | Number of characters to delete.
`P` | `INT` | Starting position (1-based).

### Outputs

Name | Type | Description
---|---|---
Return value | `ANY_STRING` | IN with L characters removed starting at position P. Same type as IN.

### Description

`DELETE(IN, L, P)` deletes _L_ characters from _IN_ starting at position _P_. Positions are 1-based.

### Example

(No specific code example provided in the source text for the DELETE function itself, but references to other string functions and the playground are present.)

### See Also

* INSERT — string insertion
* REPLACE — string replacement
* MID — middle substring

### References

* IEC 61131-3 §2.5.1.5.7
* CODESYS: DELETE
* Beckhoff TwinCAT 3: DELETE
* Fernhill SCADA: DELETE
```

--------------------------------

### Compile a Program to Bytecode

Source: https://www.ironplc.com/how-to-guides/getting-started/check-compile-run-from-cli.html

Compile your source code into an executable bytecode container using `ironplcc compile`. The output file (`.iplc`) can be run by the IronPLC virtual machine.

```bash
ironplcc compile main.st --output main.iplc
```

--------------------------------

### Map Variables to Hardware I/O Addresses

Source: https://www.ironplc.com/explanation/variables-and-io.html

Use the AT keyword to map variables directly to hardware I/O addresses. The address format is %<direction><size><address>, where direction can be I (Input), Q (Output), or M (Memory), size can be X (bit), B (byte), W (word), or D (double word), and address is the numeric identifier.

```iec61131-3
VAR
   Button AT %IX1 : BOOL;
   Buzzer AT %QX1 : BOOL;
END_VAR

```

--------------------------------

### LTIME_OF_DAY Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/ltime-of-day.html

Examples of valid literals for the LTIME_OF_DAY data type. Ensure the correct dialect is enabled for support.

```iec61131-3
LTOD#14:30:00
LTIME_OF_DAY#08:00:00
LTOD#23:59:59.999
```

--------------------------------

### Enable System Uptime with CLI Flag

Source: https://www.ironplc.com/reference/extension-library/variables/system-uptime.html

Enable system uptime variables by passing the `--allow-system-uptime-global` flag during compilation or checking.

```bash
ironplcc check --allow-system-uptime-global main.st
```

--------------------------------

### Separating Configuration Files

Source: https://www.ironplc.com/how-to-guides/getting-started/structure-a-multi-file-project.html

Keep your CONFIGURATION block in its own file to easily manage different configurations for testing and production environments.

```text
my-project/
├── config-production.st    # Production configuration (100ms cycle)
├── config-test.st          # Test configuration (different timing)
├── main.st
└── utilities.st

```

--------------------------------

### LDATE Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/ldate.html

Examples of valid LDATE literals. Ensure your dialect supports IEC 61131-3 Edition 3.

```iecst
LDATE#2024-01-15
LDATE#2024-12-31
```

--------------------------------

### LTIME Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/ltime.html

Examples of LTIME literals, including positive and negative durations with various supported units. Units are case-insensitive.

```iec61131-3
LTIME#100ms
LTIME#5s
LTIME#2h
ltime#-500ms
```

--------------------------------

### Ensure Output Directory Exists and Check Permissions

Source: https://www.ironplc.com/reference/runtime/problems/V6004.html

Use these shell commands to create the output directory if it doesn't exist and to check write permissions for the target directory.

```shell
# Ensure the output directory exists
mkdir -p /path/to/output/

# Check write permissions
ls -ld /path/to/output/
```

--------------------------------

### P4029 Error Example

Source: https://www.ironplc.com/reference/compiler/problems/P4029.html

This code demonstrates the scenario that triggers the P4029 error when a constant is used in a STRING length parameter.

```iecst
VAR_GLOBAL CONSTANT
    MAX_LEN : INT := 100;
END_VAR

FUNCTION_BLOCK MyFB
VAR_INPUT
    name : STRING[MAX_LEN];
END_VAR
END_FUNCTION_BLOCK

```

--------------------------------

### Print virtual machine version

Source: https://www.ironplc.com/reference/runtime/ironplcvm.html

Display the version number of the IronPLC virtual machine.

```bash
ironplcvm version

```

--------------------------------

### Compile a source file to a bytecode container

Source: https://www.ironplc.com/reference/compiler/ironplcc.html

Compile a PLC source file into a bytecode container using the `compile` command. Specify the output file with the `-o` flag.

```bash
ironplcc compile main.st -o main.iplc
```

--------------------------------

### P2025 Unknown Type Example

Source: https://www.ironplc.com/reference/compiler/problems/P2025.html

This code generates a P2025 error because 'UndeclaredType' is not defined. Ensure types are declared before use.

```iecst
FUNCTION_BLOCK Example
VAR
    MyVar : UndeclaredType;
END_VAR
END_FUNCTION_BLOCK

```

--------------------------------

### CONCAT Function Signature and Usage

Source: https://www.ironplc.com/reference/standard-library/functions/concat.html

This snippet details the signature, inputs, and outputs of the CONCAT function, along with its description and an example of its usage.

```APIDOC
## CONCAT

Concatenates two strings.

### Signature

```
     ┌─────────┐
IN1 ─┤         │
     │ CONCAT  ├─ OUT
IN2 ─┤         │
     └─────────┘
```

```
FUNCTION CONCAT : ANY_STRING
  VAR_INPUT
    IN1 : ANY_STRING;
    IN2 : ANY_STRING;
  END_VAR
END_FUNCTION
```

The return type matches the input type. `CONCAT` accepts `STRING`. Both inputs must share the same type.

### Inputs

Name | Type | Description  
---|---|---
`IN1` | `ANY_STRING` | The first string.  
`IN2` | `ANY_STRING` | The string to append to IN1.  

### Outputs

Name | Type | Description  
---|---|---
Return value | `ANY_STRING` | IN1 followed by IN2. Same type as the inputs.  

### Description

Returns a new string formed by appending _IN2_ to the end of _IN1_.

### Example

(No specific code example provided in the source, but the function's purpose is to combine strings like `CONCAT('Hello', ' World')` resulting in `'Hello World'`)
```

--------------------------------

### TRUNC Function Examples

Source: https://www.ironplc.com/reference/standard-library/functions/trunc.html

Illustrates how TRUNC behaves with positive and negative real numbers. The return type is determined by the variable being assigned to.

```IEC 61131-3
TRUNC(3.7) returns 3
TRUNC(-3.7) returns -3
TRUNC(0.9) returns 0

```

--------------------------------

### IEC 61131-3 Counter Program Example

Source: https://www.ironplc.com/explanation/ironplc-ecosystem.html

This program increments a counter on every scan cycle. Variables retain their values between cycles.

```IEC 61131-3
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;

END_PROGRAM
```

--------------------------------

### Check plc.xml file

Source: https://www.ironplc.com/how-to-guides/beremiz/check-beremiz-projects.html

Use this command to check a specific PLCopen XML file for errors and warnings.

```bash
ironplcc check plc.xml

```

--------------------------------

### Open Project in Development Environment - Shell

Source: https://www.ironplc.com/quickstart/helloworld.html

Open the current directory in your development environment. If using Cursor, replace 'code' with 'cursor'.

```shell
code .

```

--------------------------------

### V4001 Divide by Zero Example

Source: https://www.ironplc.com/reference/runtime/problems/V4001.html

This code demonstrates a division by zero error. Ensure divisors are not zero before performing division or modulo operations.

```IEC 61131-3
PROGRAM Main
VAR
    a : INT := 10;
    b : INT := 0;
    result : INT;
END_VAR
result := a / b;  (* Error: division by zero *)
END_PROGRAM

```

--------------------------------

### IEC 61131-3 Program Example

Source: https://www.ironplc.com/explanation/program-organization.html

This program demonstrates a simple counter that increments on each scan cycle. It also calculates a doubled value based on the counter. Use this to understand basic program structure and variable persistence between cycles.

```iec61131-3
PROGRAM main
VAR
    count : INT;
    doubled : INT;
END_VAR

(* Click Start to begin running. The program runs one scan cycle per interval. Variables keep their values between cycles, so count increases each time. *)
count := count + 1;
doubled := count * 2;
END_PROGRAM
```

--------------------------------

### LDATE_AND_TIME Literals

Source: https://www.ironplc.com/reference/language/data-types/elementary/ldate-and-time.html

Examples of valid literals for the LDATE_AND_TIME data type. Ensure your project is configured with IEC 61131-3 Edition 3 support.

```IEC 61131-3
LDT#2024-01-15-14:30:00
LDATE_AND_TIME#2024-12-31-23:59:59
```

--------------------------------

### Run a compiled program

Source: https://www.ironplc.com/reference/runtime/ironplcvm.html

Execute a compiled bytecode container file. The runtime runs continuously until interrupted.

```bash
ironplcvm run main.iplc

```

--------------------------------

### Multi-dimensional Array Validation

Source: https://www.ironplc.com/reference/compiler/problems/P2024.html

This code illustrates valid and invalid declarations for multi-dimensional arrays. The INVALID_MATRIX example shows an invalid first dimension range.

```IEC 61131-3
TYPE
    MATRIX : ARRAY [1..3, 1..4] OF REAL;  -- Valid
    INVALID_MATRIX : ARRAY [3..1, 1..4] OF REAL;  -- Error: first dimension invalid
END_TYPE
```

--------------------------------

### Invalid TwinCAT XML Structure (Missing Declaration)

Source: https://www.ironplc.com/reference/compiler/problems/P0009.html

This example shows an invalid TwinCAT XML structure where the 'Declaration' element is missing. This will cause the P0009 error.

```xml
<?xml version="1.0" encoding="utf-8"?>
<TcPlcObject Version="1.1.0.1">
  <POU Name="MAIN" Id="{00000000-0000-0000-0000-000000000000}">
    <Implementation>
      <ST><![CDATA[
myVar := myVar + 1;
      ]]></ST>
    </Implementation>
  </POU>
</TcPlcObject>

```

--------------------------------

### ADD Function Signature and Usage

Source: https://www.ironplc.com/reference/standard-library/functions/add.html

Details the signature, input/output parameters, and behavior of the ADD function.

```APIDOC
## ADD Function

### Description
Returns the sum of two or more inputs.

### Signature
```
     ┌─────────┐
IN1 ─┤         │
IN2 ─┤   ADD   ├─ OUT
IN3 ─┤         │
     └─────────┘
```

```
FUNCTION ADD : ANY_NUM
  VAR_INPUT
    IN1 : ANY_NUM;
    IN2 : ANY_NUM;
    (* ... additional inputs ... *)
  END_VAR
END_FUNCTION
```

The return type matches the input type. `ADD` accepts `SINT`, `INT`, `DINT`, `LINT`, `USINT`, `UINT`, `UDINT`, `ULINT`, `REAL`, `LREAL`. All inputs must share the same type.

### Inputs
Name | Type | Description  
---|---|---  
`IN1` | `ANY_NUM` | The first addend.  
`IN2` | `ANY_NUM` | The second addend.  

### Outputs
Name | Type | Description  
---|---|---  
Return value | `ANY_NUM` | The sum of IN1 and IN2. Same type as the inputs.  

### Detailed Description
Returns the sum of _IN1_ and _IN2_. `ADD(a, b)` is the functional form of the `+` operator: `a + b`. Both forms are equivalent.
For integer types, overflow behavior wraps around (modular arithmetic).

### Example
```iecst
PROGRAM main
VAR
  count : INT;
  doubled : INT;
END_VAR

count := count + 1;
doubled := count * 2;
END_PROGRAM
```
```

--------------------------------

### Check Individual TwinCAT File

Source: https://www.ironplc.com/how-to-guides/twincat/check-twincat-projects.html

Use this command to check a single TwinCAT source file for correctness. Ensure IronPLC is installed and accessible in your system's PATH.

```bash
ironplcc check MyProgram.TcPOU
```
Tokens:
Raw