Request a quote
Capability matrix

All tools of TIA MCP

The AI agent calls every tool by itself. Read tools never change the project; every write is backed up first, logged in the audit trail and can be undone. The list is generated directly from the current product version.

tools in total
433
areas
52
write tools – each with a backup
191
tools in a Copilot profile
≤ 128

Tool list

Service diagnostics – why the machine stopped

The PLC program traced back from the symptom, live values (OPC UA, Web API, S7, PLCSIM), device and terminal from the EPLAN PDF, the manual chapter, fault recording and a service report. Writes nothing to the PLC.

  • tia_diag_index_docsread

    Indexes the EPLAN schematic PDF (devices, terminals, PLC addresses, pages) and the operating manual PDF (chapters) for the diagnostics.

  • tia_diag_recordread

    Fault recorder for intermittent stops: samples signals, waits for a trigger and reports which signal dropped first (pre-trigger window, CSV).

  • tia_diag_reportread

    Saves a diagnostic result as an HTML/PDF service report with the Benešl Automation logo.

  • tia_diag_sourcesread

    Service diagnostics: which live-value sources work for this PLC (OPC UA, Web API, S7 PUT/GET, PLCSIM) and why the others do not.

  • tia_diag_trace_importread

    Evaluates an exported TIA Trace measurement (CSV): order of the last changes before the stop.

  • tia_diag_valuesread

    Adds values from the watch table _MCP_Diag (copied rows or 'name = value' lines) to a diagnostic session and re-evaluates the cause.

  • tia_diag_whyread

    WHY IS THE MACHINE STOPPED – service diagnostics: walks the PLC logic back from the symptom, reads live values (OPC UA → Web API → S7 PUT/GET → PLCSIM) and names the blocking condition with device, terminal, cabinet and page from the…

Guided workflows

Project handover, finishing the Unified migration, HMI test, project from a specification, virtual FAT, pre-download check and service. Tools run one after another on their own; writes wait for approval.

  • tia_workflow_continueread

    Controls a running guide: action = status (state only) | approve (approve a writing step – only after the user agreed) | done (the manual step is finished) | skip (skip the step) | retry (repeat the step after an error) | cancel.

  • tia_workflow_startread

    Starts a guide (list and inputs: tia_workflows).

  • tia_workflowsread

    Guides – prepared procedures that run TIA-MCP tools in the right order, pass results between them and stop where a human decides: predani (project handover: compile, review, audit, Safety fingerprint, I/O checklist, alarm table, handover…

PLC – programming

SCL, LAD, FBD, DBs and UDTs, block interfaces, tags, libraries, compile and download.

  • tia_add_modbus_librarywrite

    Inserts the universal Benešl Automation Modbus blocks into a PLC (SCL, S7-1500 and S7-1200/G2): typBaMbJob (job: unit ID, function 1/2/3/4/5/6/15/16, 0-based address, length, data index, period, status, counters), fbBaMbTcpClient…

  • tia_compare_blocksread

    Unified diff of two blocks (even across PLCs) after normalizing the XML.

  • tia_compile_blockread

    Compiles a single block (faster than compiling the whole PLC).

  • tia_compile_deviceread

    Compiles a device (PLC/HMI). structured=True: messages as {path:[device, Screens, screen, object], state, description} + a summary by error type (summary); only_errors omits warnings; path_filter restricts to a part of the tree (e.g.

  • tia_copy_block_between_projectswrite

    Copies blocks (and optionally the UDTs they need) from a PLC in one running TIA instance to a PLC in another (export → import Override).

  • tia_create_block_from_xmlwrite

    Creates/overwrites a block from an XML string.

  • tia_create_db_from_structwrite

    Creates a global DB or UDT from JSON: {name, kind: DB|UDT, members: [{name, datatype, start_value?, comment?, members?: [...] (nested STRUCT)}]} (via an SCL external source).

  • tia_create_lad_fbd_blockwrite

    Creates (or overwrites) an FB/FC/OB in LAD/FBD (including F_LAD/F_FBD – safety untested) from a JSON specification: {name, type: FB|FC|OB, language: LAD|FBD, number?, comment?, interface: {Input:[{name,datatype,comment?,start_value?}],…

  • tia_create_plc_tagswrite

    Creates PLC tags: tags=[{name, datatype, address ('%I0.0', '%MW10'), comment?, update?: true (overwrites existing)}].

  • tia_create_scl_blockwrite

    Creates block(s)/UDT/DB directly from SCL source text (FUNCTION_BLOCK, FUNCTION, DATA_BLOCK, TYPE).

  • tia_delete_blockwrite

    Deletes a block (a snapshot is taken before deletion – can be restored with tia_restore_snapshot).

  • tia_delete_plc_tagswrite

    Deletes PLC tags by name.

  • tia_export_blockread

    Exports a block to an XML file.

  • tia_export_data_typeread

    Exports a UDT to XML.

  • tia_export_tag_tableread

    Exports a tag table to XML.

  • tia_get_start_valuesread

    StartValues (factory parameters) from a DB – for parameter tables in operating manuals.

  • tia_global_library_infosread

    Known global libraries (without opening them): name, path.

  • tia_import_blockwrite

    Imports a block from an XML file (Override).

  • tia_import_data_typewrite

    Imports a UDT from XML. ignore = ['missing_references'] (UDT refers to a missing type – imported inconsistent), 'structural_changes', 'unit_attributes'; cultures = 'activate' | 'skip' (TIA V20+).

  • tia_import_scl_sourcewrite

    Imports an SCL file as an external source + generates blocks.

  • tia_import_tag_tablewrite

    Imports a tag table from XML. cultures = 'activate' | 'skip' (comments in languages that are not active in the project).

  • tia_instantiate_library_elementwrite

    Instantiates a MasterCopy from the library into a PLC/HMI.

  • tia_io_list_importwrite

    Create PLC tags from an I/O list (after the preview).

  • tia_io_list_previewread

    Preview of an I/O list import (XLSX/CSV from EPLAN/Excel): header detection, address normalisation (E/A and %I/%Q), data type, DI/DO/AI/AO, names by convention, duplicates and conflicts.

  • tia_library_check_versionsread

    For each library type, finds instances in the PLC/HMI and flags those that are not using the latest version (outdated).

  • tia_library_typesread

    Types and master copies in the library: library=None → project library, otherwise the name of an open global library.

  • tia_library_update_projectwrite

    Updates instances of types in the project to the latest version from the library (LibraryType.UpdateProject) – a write!

  • tia_lint_and_correct_blockwrite

    Checks and fixes variable naming in a block according to the conventions (writes!).

  • tia_lint_blockread

    Checks a block without writing: prefixes against conventions (or prefixes={section: prefix}), missing comments on parameters, unused Static/Temp.

  • tia_list_librariesread

    Open global libraries + summary of the project library.

  • tia_list_project_libraryread

    Types in the project library (Unified faceplates = LibraryType, HMI UDT, blocks) with versions and state, plus master copies.

  • tia_migrate_blockswrite

    Run the migration: rename, import into the target PLC (UDTs first) and compile.

  • tia_migrate_blocks_previewread

    Preview of migrating blocks from old projects/libraries (XML exports of any TIA version or SCL sources): convention-based renames, collisions, code review.

  • tia_open_global_librarywrite

    Opens a global library (.al21/.al20…) in the running TIA instance (read-only by default).

  • tia_protect_blockwrite

    Know-how protection of a block with a password.

  • tia_read_blockread

    Openness XML of a block (the name can also be a path 'Folder/Sub/Block').

  • tia_read_tag_tableread

    Tag table XML.

  • tia_rename_block_variablewrite

    Renames a block interface variable including all usages in the code (both SCL and LAD/FBD).

  • tia_rename_plc_tagwrite

    Renames a PLC tag (updates usages in TIA blocks symbolically).

  • tia_set_start_valueswrite

    Sets the StartValue of DB/FB members by path: {"Pamet.MaxVal": "6.0", "Enable": "TRUE"}.

  • tia_update_block_interfacewrite

    Modifies the interface of an existing block (export → XML → import): add=[{section, name, datatype, comment?, start_value?}] or {section: [...]}, remove=[names], change={name: {datatype?, comment?, start_value?}}.

  • tia_write_block_sourcewrite

    Overwrites an existing block's XML content (a snapshot of the original state is saved automatically).

Project from a specification

An Excel specification, a check and a plan for approval: PLC tags, data types, function blocks, DBs and translation.

  • tia_spec_planread

    Prepares a PLAN of the project skeleton from a specification (Excel) – nothing is written to TIA until the user approves it: tags from the IO sheet → device data types → FBs for motor/valve/analog → station DBs → station FBs + instance…

  • tia_spec_previewread

    Preview of the project skeleton from a specification (read only, nothing is written): checks the Excel (unknown types, duplicates, missing links), lists the data types, blocks and PLC tags that will be created from the IO sheet, the input…

  • tia_spec_templateread

    Specification template (XLSX) for the project skeleton: sheets Projekt, Zařízení (tag, type motor/valve/analog/pid, station, I/O links, ranges, time limits), IO (I/O list) and Návod; example=True adds a filled-in example.

PLC – reading and analysis

Reading blocks and DBs, cross references, call hierarchy, comparison.

  • tia_block_diagramread

    Draws LAD/FBD networks and GRAPH sequences of a block as SVG, like in TIA.

  • tia_block_interfaceread

    Block/DB/UDT interface as a tree {section: [members]} (flat=True: a flat list with path, type, start value).

  • tia_block_networksread

    LAD/FBD networks of the block → [{index, title, comment, language, logic[]}]; full=True adds parts (operands, instance) and wires for precise analysis.

  • tia_check_scl_instructionsread

    SCL check without writing: finds calls that are neither a system instruction, a project block nor a <TYPE>_TO_<TYPE> conversion (typically invented functions), with 'did_you_mean' suggestions; with device_name it also knows project…

  • tia_get_cross_referencesread

    Cross references of a block or PLC tag (Openness CrossReferenceService).

  • tia_list_blocksread

    PLC block list (name, type, folder path).

  • tia_list_data_typesread

    List of UDTs.

  • tia_list_tag_tablesread

    List of PLC tag tables.

  • tia_lookup_instructionread

    Reference of S7-1200/1500 system instructions (timers, counters, conversions, strings, OUC/S7/Modbus communication, PID, Motion, diagnostics, data logging…): name, kind (FB with instance / function), parameters, availability per CPU.

  • tia_plc_tagsread

    PLC tags (name, type, address, comment) from all or one table; pattern = regex on name/address.

  • tia_read_block_sclread

    Readable content of a block without XML: for SCL blocks the reconstructed SCL text, for LAD/FBD networks with pseudologic ('#oRun := (RISING(#iStart) OR #oRun) AND NOT #iStop'), + interface and metadata.

  • tia_read_data_typeread

    UDT XML.

  • tia_read_db_structureread

    Structure of a DB/instance DB/UDT: flat list of members (path, datatype, start_value, comment) + tree.

HMI – WinCC Unified and Comfort

Screens, items, faceplates, scripts, tags, Comfort → Unified migration, screenshots.

  • tia_describe_hmi_screenread

    Textual description of a screen (buttons, texts) – for the 'Operation' chapter of the operating manual.

  • tia_export_hmi_screenread

    Exports an HMI screen to XML.

  • tia_export_hmi_tag_tableread

    Exports an HMI tag table to XML (Comfort/Advanced).

  • tia_get_alarmsread

    HMI / ProDiag alarms – a basis for a fault table.

  • tia_hmi_comfort_export_allread

    Complete export of classic WinCC (Comfort/Advanced) to out_dir plus manifest.json for re-import (tia_hmi_comfort_import_all): screens, tag tables and kinds = text_lists, graphic_lists, connections, cycles, templates, popups, slideins,…

  • tia_hmi_comfort_screen_itemsread

    Parsed overview of a Comfort screen (instead of XML): faceplate instances with their interface (tags/texts), objects with position, text, events (function+parameters) and dynamizations.

  • tia_hmi_migrate_faceplateswrite

    Completes faceplates after a Comfort→Unified migration: for each Comfort instance, finds an empty container at the same position (or creates a new one), sets its type to '<type><suffix>' (latest version), names it after the Comfort one…

  • tia_hmi_migrate_udt_tagswrite

    Fixes HMI UDT tags broken by the migration: for tags that were of type UDT_X in Comfort, sets them in Unified to 'UDT_X<suffix> V <version>' (HMI UDT from the project library) and restores their address from Comfort.

  • tia_hmi_unified_add_color_dynamizationwrite

    Bit-based color dynamization (indicator light): tag bit==1 → on_color, otherwise off_color.

  • tia_hmi_unified_add_tag_dynamizationwrite

    Direct dynamization of a property by a tag (ProcessValue, Visible, …) without a mapping table.

  • tia_hmi_unified_create_itemwrite

    Creates an object (Circle, Rectangle, TextBox, Button, Line, Polyline, IOField, FaceplateContainer, …) and sets its properties.

  • tia_hmi_unified_delete_itemswrite

    Deletes objects by a list of names / regex / type (at least one filter is required).

  • tia_hmi_unified_drawwrite

    Draw WinCC Unified screen objects from JSON (rectangles, texts, circles, IO fields, buttons…) incl.

  • tia_hmi_unified_dumpread

    JSON snapshot of Unified screens (objects, properties, dynamizations, scripts) – backup/diff; Unified screens cannot be exported to XML.

  • tia_hmi_unified_export_alarms_csvread

    Exports both discrete and analog Unified alarms to CSV (kind;Name;AlarmClass;EventText;Tag;TriggerBit;Limit…).

  • tia_hmi_unified_export_tags_csvread

    Exports Unified HMI tags to CSV (';', UTF-8 BOM – opens in Excel): name;DataType;Connection;PlcTag;Address;…

  • tia_hmi_unified_faceplate_instancesread

    All faceplate containers: screen, type+version, position, interface values, flags (no_type = empty container after migration, empty:<properties> = unbound).

  • tia_hmi_unified_faceplate_typesread

    Faceplate types in the project library with versions, native size and interface property names (determined using a temporary container on the helper screen '__mcp_probe', which is then deleted).

  • tia_hmi_unified_find_itemsread

    Finds objects across screens by name / type / text regex.

  • tia_hmi_unified_fix_migrationwrite

    Automatic fixes after a Comfort→Unified migration: screen names with '\' (+ scripts), nonexistent tags with commas/dots.

  • tia_hmi_unified_import_tags_csvwrite

    Bulk creation/update of HMI tags from CSV (header as in the export; name is required, other columns are set via set_tag – DataType, Connection, PlcTag, Address, AcquisitionCycle, InitialValue…).

  • tia_hmi_unified_lintread

    Checks Unified HMI without compiling: containers without a type / unbound, nonexistent tags (with a suggested fix), scripts with migration artifacts, screens with '\' in the name, objects outside the screen.

  • tia_hmi_unified_place_faceplatewrite

    Places a faceplate container of a type from the project library (default latest version) and maps the interface {"Ventil": "DB_Ventily\SO_1_S_011", "Jmeno": "SO1S04"}.

  • tia_hmi_unified_proberead

    Debugging screenshot of the runtime + visible texts (visible_texts – Unified draws screens as SVG) for building 'click' in tia_hmi_unified_screenshots; runtime_down = the web client reports that the runtime is not running.

  • tia_hmi_unified_rename_screenwrite

    Renames a screen and fixes ChangeScreen("…") in scripts.

  • tia_hmi_unified_render_svgread

    Schematic SVG preview of a screen (rectangles/circles/lines/texts, faceplates as dashed frames with their type) – a quick visual check of the layout without runtime.

  • tia_hmi_unified_replace_in_scriptswrite

    Bulk replacement in all scripts (regex or plain text).

  • tia_hmi_unified_replace_tag_refswrite

    Redirects tag references in dynamizations and faceplate interfaces: mapping {old: new}; auto_fix fixes nonexistent tags according to migration rules ('DB_x,y,z' → 'DB_x_y_z', '"DB_x.y"' → 'DB_x_y').

  • tia_hmi_unified_restorewrite

    Restores screens from a dump (tia_hmi_unified_dump): properties (geometry, colors, texts, ContainedType, faceplate interfaces), creates missing objects, delete_extra deletes objects not in the dump, re-creates tag dynamizations and event…

  • tia_hmi_unified_screen_itemsread

    Objects of a Unified screen: type, position/size, text, style, faceplate interface, dynamization (tag, mapping table), optionally event scripts.

  • tia_hmi_unified_screensread

    List of WinCC Unified HMI screens (objects, not XML).

  • tia_hmi_unified_screens_overviewread

    Overview of Unified screens: size, background color, number of objects by type.

  • tia_hmi_unified_screenshotsread

    Screenshots of WinCC Unified Runtime screens via the web client (Playwright).

  • tia_hmi_unified_scriptsread

    Scripts of event handlers and script dynamizations (screen, object, event, code) + known issues (not-found tag, octal escape, '\' in screen name).

  • tia_hmi_unified_set_all_screenswrite

    Same properties for all screens (e.g. white background: {"BackColor": "#FFFFFF"}).

  • tia_hmi_unified_set_faceplate_interfacewrite

    Sets the interface properties of an existing faceplate container (tag or static value).

  • tia_hmi_unified_set_propertieswrite

    Sets properties of a screen object: {"Left": 10, "BackColor": "#FF0000", "Visible": false, "HorizontalTextAlignment": "Center", "Font.Size": 30, "Text": "Nový text", "Name": "NovyNazev"}.

  • tia_hmi_unified_set_properties_bulkwrite

    Same properties for all objects of a screen matching a filter (name regex / type).

  • tia_hmi_unified_set_screenwrite

    Screen properties: {"BackColor": "#FFFFFF", "Name": "nova", "Width": 1920, ...}.

  • tia_hmi_unified_set_scriptwrite

    Sets the JS script of an object's event handler (e.g.

  • tia_hmi_unified_set_tagwrite

    Sets/creates an HMI tag: {"Connection": "Connection_2", "Address": "%DB1.DBX32.0", "DataType": "UDT_Ventily_UP V 0.0.1", "AcquisitionCycle": "T1s", "InitialValue": "0"}.

  • tia_hmi_unified_stretch_headerwrite

    Stretches the header (rectangle with Top<=max_top + the title text field) across the full width and centers the text.

  • tia_hmi_unified_tagsread

    WinCC Unified HMI tags (name, type, PLC tag, connection).

  • tia_hmi_unified_tags_exread

    Unified HMI tags with type, address, connection, TagType (Simple/UDT/Array), optionally UDT members.

  • tia_hmi_unified_transformwrite

    Bulk movement of objects: mode 'shift' (by dx,dy) | 'center_h' | 'center_v' | 'center' (center the content's bounding box on the screen).

  • tia_hmi_unified_update_faceplate_versionswrite

    Switches containers of a given type (or all) to version to_version (default latest); the interface is preserved.

  • tia_import_hmi_screenwrite

    Imports an HMI screen from XML.

  • tia_import_hmi_tag_tablewrite

    Imports an HMI tag table from XML.

  • tia_list_hmi_screensread

    List of HMI screens.

  • tia_list_hmi_tag_tablesread

    List of HMI tag tables.

  • tia_read_hmi_screenread

    HMI screen XML.

Unified faceplates

Faceplate templates for a motor, valve, analog value and PID, mapping UDTs and DBs to signals and screen generation.

  • tia_hmi_unified_faceplate_templatesread

    Lists the faceplate/object templates for WinCC Unified (motor, valve, analog, PID) with their signal interface, a draw-spec preview and the manual conversion procedure.

  • tia_hmi_unified_generate_faceplatewrite

    Maps PLC UDT/DB members to a faceplate template (tolerant to naming) and creates a template screen, a tag-bound screen, or places instances of an existing library type.

Hardware and networks

Devices, modules, addresses, IP, PROFINET, subnets, topology.

  • create_devicewrite

    Creates a device from a TypeIdentifier (e.g.

  • get_hardware_detailsread

    HW tree of the device including MLFB (TypeIdentifier).

  • get_networksread

    Subnets and nodes in the project.

  • list_devicesread

    List of devices (PLC, HMI, …) in the project including groups.

  • list_technology_objectsread

    PLC technology objects.

  • tia_compare_devicesread

    Compares two PLCs: blocks present in only one, differing, matching (offline, via XML hash).

  • tia_connect_axis_drivewrite

    Axis TO → SINAMICS drive: connects actuator and encoder to the PROFIdrive telegram of the drive object (main telegram or a given number, e.g.

  • tia_connect_portswrite

    Connects two Ethernet/PROFINET ports (topology).

  • tia_connect_profinetwrite

    Connects an IO device (ET 200SP IM, drive, HMI...) to the controller CPU's PROFINET IO system.

  • tia_connect_subnetwrite

    Connects a device's network interface (HMI, PLC, switch...) to an Ethernet subnet without an IO system; the subnet is created if it does not exist.

  • tia_disconnect_portwrite

    Removes all connections of the given port (topology).

  • tia_export_caxread

    Exports AutomationML (CAx) for EPLAN.

  • tia_find_typesread

    Openness API diagnostics: lists .NET types (including enum values) whose name contains the pattern.

  • tia_get_all_profinet_inforead

    Table of Profinet names, IPs and devices across the project.

  • tia_get_device_ip_addressesread

    IP addresses of a device's interfaces.

  • tia_get_object_propertiesread

    Introspection: properties of an object in the Openness tree (path e.g.

  • tia_hw_inventoryread

    Hardware bill of materials: all order numbers with firmware and quantities, device types, IP addresses and PROFINET names; export to Excel.

  • tia_import_caxwrite

    Imports AutomationML (CAx) from EPLAN.

  • tia_invoke_object_methodwrite

    Calls a method of an object in the Openness tree (generic – use with caution).

  • tia_plc_protectionwrite

    CPU protection (V20/V21): without parameters only reads the state.

  • tia_plug_modulewrite

    Plugs a module into the device's rack (ET 200SP / S7-1500) at the given slot.

  • tia_read_hw_addressesread

    I/O addresses of the device's modules (incl.

  • tia_set_device_ip_addresswrite

    Sets the IP address (and mask) of an interface.

  • tia_set_hw_addresswrite

    Sets the module's starting I/O address.

  • tia_set_object_propertywrite

    Sets a property of an object (generic write – use with caution).

Commissioning

Watch and force tables, user constants, instruction reference.

  • tia_accessible_devicesread

    Devices reachable on the network via a PC interface (name, IP, series, MAC), like 'Accessible devices' in TIA.

  • tia_compare_onlineread

    Compares the offline program with the PLC online (real PLC or PLCSIM) without writing: what differs, what is missing in the PLC and what is missing in the project.

  • tia_create_user_constantswrite

    Creates user constants: name, data type, value, comment; update=True overwrites existing ones.

  • tia_delete_user_constantswrite

    Deletes user constants by name (optionally only from one tag table).

  • tia_delete_watch_tablewrite

    Deletes a watch table (a snapshot is saved – tia_restore_snapshot brings it back).

  • tia_download_to_plcwrite

    Download to a REAL PLC – disabled for the agent until the user turns on the switch "Agent may download to a real PLC" in the web GUI (Dashboard; the default without the switch comes from TIA_MCP_ALLOW_PLC_DOWNLOAD=1 in .env).

  • tia_export_watch_tableread

    Exports a watch or force table to XML (SimaticML).

  • tia_import_watch_tablewrite

    Imports a watch or force table from XML (override).

  • tia_list_constantsread

    PLC user constants (name, type, value, comment); include_system=True adds system constants (HW identifiers, OB numbers – useful for LADDR, DeviceStates etc.).

  • tia_list_watch_tablesread

    Watch tables (including groups) and the PLC force table with the number of entries.

  • tia_online_fingerprintread

    Fingerprints of the program in the online PLC – a quick check whether the PLC has changed (address defaults to the PLC IP from the project).

  • tia_online_statusread

    Online state of the CPU, configured connection and available PC interfaces; optionally a short probe connection.

  • tia_prodiagread

    ProDiag: supervision blocks and their supervisions (type, text, alarm class) from the export.

  • tia_read_watch_tableread

    Entries of a watch or force table: symbol/address, display format, modify/force value, triggers, comment.

  • tia_upload_stationwrite

    Uploads a station from a PLC (IP address) into the project as a new device – hardware and program.

  • tia_write_force_tablewrite

    Writes entries of the PLC force table (offline table content only – forcing itself is activated online in TIA).

  • tia_write_watch_tablewrite

    Creates or extends a watch table: entries with symbol or address, display format, modify value, triggers and comment, or comment rows; groups; append or replace mode.

Simulation and virtual FAT

PLCSIM Advanced: instance control, tag read/write, trace, test scenarios.

  • tia_download_to_plcsimwrite

    Compiles the PLC and downloads it from the open project into the SIMULATOR (S7-PLCSIM / PLCSIM Advanced) via Openness.

  • tia_plcsim_controlwrite

    Control a PLCSIM Advanced instance: action = register | power_on | power_off | run | stop | memory_reset | step (N cycles in single-step mode) | free_run | unregister.

  • tia_plcsim_readread

    Reads current tag values from the simulated PLC.

  • tia_plcsim_scenario_templateread

    XLSX test scenario template (Step | Set | Wait | Cycles | Expect | Within [ms] | Tolerance | Note) with logo and examples; if a PLCSIM Advanced instance is running, adds a sheet with all tags.

  • tia_plcsim_statusread

    S7-PLCSIM Advanced: is the API installed (api_version), is the Runtime Manager running, network mode, which instances exist (state, CPU, IP) and whether the PLCSIM version matches the TIA version (tia_compat).

  • tia_plcsim_tagsread

    Tags of the simulated PLC (I/Q/M/DB from the instance tag list) with type and area; contains = name filter.

  • tia_plcsim_testwrite

    Virtual FAT: runs a test scenario (set / wait or cycles / expect with timeout and tolerance) on the simulated PLC and optionally saves an XLSX protocol with the company logo.

  • tia_plcsim_traceread

    Records tag values from the simulated PLC (control loops, ramps, sequences): periodic reads every interval_ms for duration_ms; returns min/max/last value and number of changes, optionally a CSV (';' separator).

  • tia_plcsim_writewrite

    Writes tag values to the simulated PLC (type from the tag list).

Virtual FAT – scenarios

Test scenarios from DBs, alarms, an I/O list and a state machine, executed in PLCSIM Advanced with tag recording to CSV.

  • tia_vfat_planread

    Virtual FAT, step 1 – test plan from the project (read only): recognizes motors, valves, analog measurements and PIDs in the global DBs (as TIA → BAVIS), assigns roles (command, PLC output, feedback, fault, reset) and generates test…

  • tia_vfat_runwrite

    Virtual FAT, step 2 – executes the plan (from tia_vfat_plan, optionally edited) against a SIMULATED PLC: process models (motor, valve, analog, PID) in a closed loop read the PLC outputs and write the responses, test cases issue commands…

Documentation, review and reports

Code review, safety report, change report, I/O checklist, operator manuals, translations.

  • tia_block_doc_contextread

    Everything needed to document a block in one call: interface, code (SCL / LAD-FBD pseudo logic), existing titles and comments, what is missing, callers, suggested language.

  • tia_change_reportread

    Readable change report between project versions (git repo from tia_export_project_to_text): blocks (interface, network diffs), safety blocks, UDTs, tags, hardware – as Markdown.

  • tia_dump_allread

    Export the whole project (JSON + XML) to a folder; git_commit=True commits the result.

  • tia_export_io_checklistread

    FAT/SAT I/O checklist as XLSX (address, tag, type, comment, table + OK/NOK, date, tester, note columns).

  • tia_export_project_textsread

    Exports project texts to XLSX (translations): source language (default reference language) and target language (must be active).

  • tia_export_project_to_textread

    Deterministic text export of the project (blocks, UDT, tags, HW) for git diff/commit.

  • tia_generate_call_hierarchyread

    Mermaid graph of the block call hierarchy.

  • tia_generate_io_checklistread

    List of physical I/O (%I/%Q) with comments – a basis for an FAT/SAT checklist.

  • tia_generate_network_topologyread

    Mermaid graph of network topology based on IP addresses.

  • tia_generate_scl_from_csvread

    Generates an SCL DATA_BLOCK from a CSV 'Name,Type' (without writing to the project).

  • tia_generate_state_machineread

    Structure of a sequential block (CASE) for a Mermaid state diagram.

  • tia_get_project_languagesread

    Project languages.

  • tia_git_commitwrite

    Exports the project to repo_dir and commits it (git init on first use).

  • tia_git_diffread

    What has changed in the project since the last commit (after a fresh export).

  • tia_import_project_textswrite

    Imports project texts.

  • tia_list_vci_workspacesread

    VCI workspaces of the project (listing only).

  • tia_manual_collectread

    Gathers material for the operating manual into JSON: BOM (MLFB), network, blocks + call hierarchy + comments/interface, StartValues of the specified DBs, physical I/O, HMI screens (Comfort XML / Unified), alarms (Unified), F-signature.

  • tia_manual_renderread

    Fills the Benešl Automation LaTeX template with data (data.json from tia_manual_collect) and texts (content.json from the agent), matches screenshots (<screen name>.png in screenshots_dir) and compiles the PDF (pdflatex).

  • tia_manual_schemaread

    Schema of content.json for the manual generator – what the agent should write and in what format.

  • tia_project_add_languagewrite

    Add a language to the project's active languages (e.g.

  • tia_read_text_fileread

    Reads a text file (JSON/XML/SCL/log) from disk – for the manual's data.json, exports, snapshots.

  • tia_review_blockread

    Code review of a block (deterministic checks, no changes): double coils/writes, unused variables, unwritten outputs, temp read before write, CASE without ELSE, division by variable, conditionally called timers/edges, unchecked…

  • tia_review_cross_plcread

    Cross-PLC and network check: duplicate IP addresses / PROFINET names, communication instances per PLC (PUT/GET, TSEND_C, MB_CLIENT…), same-named global DBs and UDTs with different structure (communication DBs that drifted apart) and DBs…

  • tia_review_programread

    Code review of all FB/FC/OB in a PLC (or folder): totals by severity, worst blocks, findings and global operands written from several blocks.

  • tia_set_block_documentationwrite

    Write documentation into a block without changing code: block title/comment, network titles/comments, variable comments.

  • tia_texts_apply_translationsread

    Write translations into the XLSX (file only): fills all rows with the same source text, applies the glossary, rejects translations with broken placeholders.

  • tia_texts_statsread

    Statistics of a project text export: source/target languages, missing translations, categories.

  • tia_texts_translation_batchread

    Batch of UNIQUE texts to translate from the export with matching glossary terms.

Project audit

Review of all PLCs, a check across PLCs and the network, unused blocks, UDTs and tags; one verdict and a report.

  • tia_find_unusedread

    Unused blocks / DBs, UDTs and PLC tags (project clean-up): a reference is a name appearing in the text of another block (SCL, LAD/FBD operands, interface) from the index; OBs are entry points, an FB is paired with its instance DB, blocks…

  • tia_project_auditread

    One-shot read-only AUDIT of the project: code review of all PLCs (errors/warnings/recommendations, worst blocks), cross-PLC and network checks (duplicate IPs / PROFINET names, connection IDs, communication, drifted shared DBs/UDTs) and…

Manual update

Comparing the source data with the previous manual version, mapping changes to chapters and applying edits with a document revision.

  • tia_manual_updateread

    Updates a finished operating manual after project changes.

Alarms

PLC alarm export and import, alarm tables, alarms from a list.

  • tia_alarm_tableread

    Fault table XLSX: WinCC Unified alarms + Program_Alarm/ProDiag (source, name, text, class, trigger, info) with empty cause / remedy columns for the operator manual.

  • tia_alarms_from_listwrite

    Bit alarms from a list: PLC DB with a Word array (bit = alarm), HMI tags and WinCC Unified discrete alarms (trigger tag + bit, class, text).

  • tia_plc_alarms_exportread

    Export PLC alarms to XLSX: Program_Alarm instance texts, alarm text lists, ProDiag supervisions (S7-1500), alarm classes.

  • tia_plc_alarms_importwrite

    Import PLC alarms from XLSX (texts | textlists | supervisions | classes).

Alarm review

Static review of WinCC Unified alarms and PLC messages per ISA-18.2 and EEMUA 191 with a score and a report.

  • tia_alarm_reviewread

    Review of the alarm database against ISA-18.2 / EEMUA 191 (read only): priority distribution against the recommended one (5 % high / 15 % medium / 80 % low), missing or duplicate texts, alarms without a class, medium/high priority without…

SIMATIC SD documents

Export/import of blocks as readable text (.s7dcl) and import preview with diff.

  • tia_export_documentsread

    Exports blocks (SCL, LAD, FBD, DB, OB…) and UDTs as SIMATIC SD documents (.s7dcl, texts in .s7res) – readable text ideal for git diff and code review.

  • tia_import_documentswrite

    Imports SIMATIC SD documents (.s7dcl/.s7res) from a folder (recursively) – UDTs first.

  • tia_preview_importread

    Import preview without writing: what will be created, overwritten or stay unchanged, with a unified diff against the current project.

Safety

F-signature and safety report.

  • tia_get_f_signatureread

    Offline F-signatures of all F-blocks plus the safety program signatures.

  • tia_safety_reportread

    Safety program overview of an F-CPU: F-runtime groups (F-OB, cycle, max.

F-program review

Extended review of an S7-1500F F-program: F-I/O, signatures and baseline, cycles and watchdog, structure. An aid, not a validation.

  • tia_safety_reviewread

    Extended review of the S7-1500F safety program (helper, not a replacement for certified validation per IEC 61508 / ISO 13849).

Migration from other platforms

Beckhoff, B&R, CODESYS/WAGO and Schneider → Siemens: SCL, LAD, data types, I/O, Unified HMI, axes, report; STL → SCL, GRAPH reading.

  • tia_convert_stl_to_sclread

    STL (AWL) → SCL migration without writing: bit logic (AND before OR, brackets, S/R, edges), accumulator and arithmetic, comparisons, jumps, CALL.

  • tia_create_graph_blockwrite

    Creates an S7-GRAPH block from a specification (steps, actions, transitions, supervisions); branches and jumps are derived automatically.

  • tia_migrate_applywrite

    Migration to Siemens – imports the converted result into the open TIA project: constants, tags, technology objects, SCL/LAD blocks, OB1, HMI tags and screens, alarms and compile.

  • tia_migrate_convertread

    Migration to Siemens – converts the source project into TIA sources: ST → SCL, LD → LAD, SFC → SCL, UDTs, DBs, PLC tags, constants, axes → technology objects, alarms, WinCC Unified screens and an HTML report with effort estimate.

  • tia_migrate_scanread

    Migration to Siemens – survey of a source project (Beckhoff TwinCAT 3, B&R Automation Studio, PLCopen XML from CODESYS/WAGO/Schneider Machine Expert, Schneider Control Expert): POUs, data types, I/O, tasks, HMI screens, libraries.

  • tia_read_graphread

    GRAPH blocks: steps (number, name, initial, actions with qualifiers), transitions with operands, branches and links – a readable overview of the sequence without XML.

Technology objects

Axes, cams, measuring inputs and PID: creation, parameters, leading axes; users and roles (UMAC).

  • tia_axis_configurewrite

    Axis (technology object) setup with readable keys: max velocity, dynamics, software limits, modulo, gear and units.

  • tia_create_technology_objectwrite

    Creates a technology object: to_type 'TO_PositioningAxis' | 'TO_SpeedAxis' | 'TO_SynchronousAxis' | 'TO_ExternalEncoder' | 'TO_Cam' | 'PID_Compact' …; the version must match the CPU firmware.

  • tia_set_to_masterswrite

    Synchronous axis (TO_SynchronousAxis) or kinematics (TO_Kinematics – conveyor tracking): adds leading axes/encoders – setpoint or actual value coupling.

  • tia_set_to_parameterswrite

    Sets technology object parameters; also returns the previous values – calling again with them undoes the change.

  • tia_to_parametersread

    Parameters of a technology object (axis, PID…) with values; pattern = regex on the parameter name.

Software Units

Units, namespaces, relations, published blocks, moving blocks into units and checks.

  • tia_unit_checkread

    Checks Software Units: empty units, relations to missing units or DBs, published objects without a namespace.

  • tia_unit_createwrite

    Creates (or updates) a Software Unit with a namespace preset and author.

  • tia_unit_create_sclwrite

    Creates blocks, UDTs and DBs from SCL source directly inside a Software Unit.

  • tia_unit_move_blockswrite

    Copies or moves blocks from the main program into a Software Unit (import first, original deleted only afterwards).

  • tia_unit_relationwrite

    Software Unit relation to another unit, a global DB outside units or a technology object; can also remove it.

  • tia_unit_set_accesswrite

    Sets Published/Unpublished access and/or namespace of blocks and types in a unit; returns previous values.

  • tia_unitsread

    PLC Software Units (V18+): units, namespace preset, relations, blocks and types with namespace and Published/Unpublished access.

SINAMICS drives

Startdrive: drive creation, parameters, telegrams, drive comparison and Excel export.

  • tia_drive_compareread

    Compares the parameters of two drives (series machines, drive replacement).

  • tia_drive_createwrite

    Creates a SINAMICS drive by order number; the firmware version comes from the hardware catalog.

  • tia_drive_export_paramsread

    Exports drive parameters to Excel or CSV.

  • tia_drive_paramsread

    Reads SINAMICS drive parameters by number, range or text search, optionally with enumeration values.

  • tia_drive_set_paramswrite

    Writes drive parameters offline in the project and returns the previous values for rollback.

  • tia_drive_telegramwrite

    Sets the PROFIdrive telegram of a drive object (main, supplementary, safety, torque).

  • tia_drivesread

    SINAMICS drives in the project (Startdrive): drive objects, telegrams and key data.

OPC UA

PLC server interfaces: generation from DBs, UANodeSet import and export.

  • tia_opcua_access_controlread

    OPC UA server access control of a PLC (TIA V21, CPU FW 3.1+): roles (with the mapped project role and Browse/Read/Write/Call/ReceiveEvents/ReadRolePermissions per namespace) and namespace access restrictions (signing, encryption, session).

  • tia_opcua_exportread

    Exports an OPC UA server interface as UANodeSet XML (for MES/SCADA or editing and re-import); also reference namespaces (companion specifications) and SIMATIC interfaces.

  • tia_opcua_export_serverread

    Exports the complete OPC UA server address space of a CPU as UANodeSet XML (like 'Export OPC UA XML' in the CPU properties) – for offline configuration of OPC UA clients / SCADA.

  • tia_opcua_generatewrite

    Generates an OPC UA server interface from global DBs (objects, structures, variables mapped to DB members).

  • tia_opcua_importwrite

    Imports an OPC UA server interface from UANodeSet XML with variable mappings to DB members.

  • tia_opcua_interface_setwrite

    Settings of a PLC OPC UA server interface: Enabled / Author (writability checked), for reference namespaces GenerateNodes and UseStringNodeIds (V21), for SIMATIC interfaces UseStringNodeIds.

  • tia_opcua_interfacesread

    Lists the PLC's OPC UA server interfaces, reference namespaces and SIMATIC interfaces.

  • tia_opcua_namespace_restrictionwrite

    Access restriction of an OPC UA server namespace (TIA V21): values = {"SigningRequired": true, "EncryptionRequired": true, "SessionRequired": true, "ApplyRestrictionsToBrowse": false}.

  • tia_opcua_rolewrite

    OPC UA server role of a PLC (TIA V21, CPU FW 3.1+, OpcUaAccessControl on): standard=True adds a standard role (Anonymous, AuthenticatedUser, Observer, Operator, Engineer, Supervisor, ConfigureAdmin, SecurityAdmin), permissions = {"Read":…

  • tia_opcua_server_settingswrite

    OPC UA server/client settings of a CPU (attributes of the OPC UA item): without values reads everything (OpcUaServer, OpcUaPort, OpcUaAccessControl, OpcUaGuestAuthentication, OpcUaPasswordAuthentication, OpcUaMaxSessions, …) and lists the…

  • tia_opcua_userswrite

    OPC UA server users of a CPU without UMAC (FW < 3.1; user name + password): list without parameters; create / set_password with the password only from password_file or password_env – never returned or logged; delete removes.

IP plan and PROFINET

IP addresses and PROFINET names via Excel: export, check, apply, topology comparison.

  • tia_connection_createwrite

    Creates a communication connection PLC↔PLC or PLC↔third-party device (TIA Portal V21+).

  • tia_connection_deletewrite

    Deletes a communication connection (TIA Portal V21+).

  • tia_connection_setwrite

    Changes connection properties (TIA Portal V21+) – ID (hex text), ports, TSAP, active connection establishment, names, the address of an unspecified partner, AccessPoint/Online for HMI connections.

  • tia_connectionsread

    Communication connections of the project (TIA Portal V21+): S7, TCP, ISO-on-TCP, UDP, ISO, FDL and HMI connections.

  • tia_gsd_exportread

    Exports the GSDML file of an I-device (TIA Portal V21+) – for a higher-level controller in another project or system.

  • tia_idevice_configurewrite

    I-device: enables/disables I-device mode on the CPU's PROFINET interface (the IO controller remains), assigns it to the higher-level IO system (higher_level = name of the IO system or of the higher-level controller's device) and creates /…

  • tia_ip_plan_applywrite

    Applies IP addresses and PROFINET names from the Excel IP plan to the project (only if the plan has no errors).

  • tia_ip_plan_checkread

    Compares an edited IP plan with the project: changes, unknown interfaces, plan errors, topology differences.

  • tia_ip_plan_exportread

    Exports the project's IP plan and PROFINET names (and port topology) to Excel with checks.

  • tia_mrp_configurewrite

    MRP (PROFINET ring redundancy): creates an MRP domain in the subnet (or uses an existing one), assigns the members' interfaces to it and sets the role.

  • tia_network_topologyread

    Network topology with subnets, IO systems and port interconnections; export to CSV, Excel, SVG and draw.io.

  • tia_profinet_overviewread

    PROFINET configuration (read only): subnets with MRP domains and sync domains (participants, send clock), IO systems with IO devices (RT class, sync role, update time, watchdog), I-device interfaces of CPUs with transfer areas (direction,…

  • tia_sync_domain_configurewrite

    Sync domain (IRT / isochronous PROFINET): creates a domain in the subnet, assigns the members' interfaces and sets the synchronization role and RT class.

Multiuser Engineering

Project servers, local sessions, object marking and check-in.

  • tia_mu_commitwrite

    Multiuser check-in: commits the marked changes of the local session to the server with a comment.

  • tia_mu_create_sessionwrite

    Multiuser: creates a local session for a server project.

  • tia_mu_markwrite

    Multiuser: marks or unmarks PLC blocks in the local session before editing.

  • tia_mu_markingsread

    Multiuser: objects marked in the local session, conflicts and up-to-date state.

  • tia_mu_open_sessionread

    Multiuser: opens a local session file.

  • tia_mu_serversread

    Multiuser Engineering: configured project servers, server projects and open local sessions.

Engineering tools

HW catalog, EPLAN ↔ TIA (AML), library upgrade, safety from C&E matrix, unit tests, Test Suite.

  • tia_cax_compareread

    Compares AutomationML from EPLAN with the project: hardware, network addresses and tags.

  • tia_hw_catalogread

    Searches the TIA hardware catalog by order number or text and returns type identifiers and versions.

  • tia_library_upgradewrite

    Upgrades a global library from an older TIA version (.al1x or archive) to the current version; the original stays unchanged.

  • tia_safety_ce_generatewrite

    Generates an F-LAD/F-FBD block from a cause & effect matrix (Excel); preview by default, to be validated by a responsible person.

  • tia_testsuitewrite

    TIA Test Suite via Openness: status (rule sets, test cases with scope, test sets, system tests), export rule sets / test cases / system tests to a file, run style guide, load and run application tests.

  • tia_testsuite_managewrite

    Test Suite changes and runs: load rule sets / test cases / test sets / system tests, create from library master copies, copy rule set scope, set the OPC UA scope of a system test, run test sets and system tests, delete.

  • tia_unit_test_generatewrite

    Generates a unit test FB for an FB/FC from test cases (inputs, expected outputs, cycles) and an OB that runs it.

  • tia_unit_test_runwrite

    Runs the unit tests of a block in PLCSIM Advanced and reads the results.

Tracing and comparison

Signal path from the PLC to the HMI screens (tags, blocks, screens, scripts).

  • tia_trace_signalread

    Traces a signal across the project: PLC tag → usage in the program (cross references) → WinCC Unified HMI tags pointing to it → screens and items with a dynamization or script → alarms.

Security and users

UMAC users and roles, project and PLC protection, password policy, certificates.

  • tia_certificatesread

    Certificates in a device's certificate store (Id, CN, validity, private key yes/no) – never the private keys; without device_name for all PLCs of the project.

  • tia_plc_access_controlwrite

    PLC access control via users (CPU FW 3.1+): sets the mode and returns the previous one.

  • tia_protect_projectwrite

    Enables project protection and user management (UMAC) with an administrator account; password only from a file or environment variable, requires confirm=True.

  • tia_security_certificatewrite

    Certificates in a device's store (device_name = CPU / HMI): action=create (usage OpcUaServer | OpcUaClient | OpcUaClientServer | WebServer | Tls, common_name, validity, subject alternative names, signature), action=import (.cer/.crt/.der,…

  • tia_security_certificate_exportread

    Exports the public part of a certificate (Id or CN) from a device's store to a file (.cer/.crt/.der) – without the private key.

  • tia_security_master_secretwrite

    Protection of confidential PLC configuration data (Master Secret): action = protect | protect_all (V21 – also all other downloadable configuration data) | unprotect_all (V21) | change_password | unprotect | reset.

  • tia_security_overviewread

    Project and PLC security in one place: users, roles, password policy and, per PLC, access level, access control, confidential data protection, certificates, Syslog and web server users.

  • tia_security_syslogwrite

    Syslog. With device_name the CPU settings (S7-1500 FW 3.1+): EnableSystemLogging, TransportProtocol (UDP / TLS), target servers address + port (add / delete).

  • tia_security_webserver_userswrite

    Web server users of a CPU (without UMAC): list without parameters; create with permissions (ReadTag, ModifyTag, DoDiagnosis, …) and a password via password_file / password_env; permissions without create change the permissions; delete…

  • tia_umac_device_rightsread

    Device function rights (PLC/HMI) that can be assigned to a custom role.

  • tia_umac_password_policywrite

    Project password policy: read or set (length, digits, special characters, ageing, reuse).

  • tia_umac_rolewrite

    Custom UMAC role: create, comment, engineering rights, device rights, delete.

  • tia_umac_umcwrite

    UMC (central user management) in a protected project: action = list | create_user (offline UMC user without a UMC server) | create_group (offline group) | update (roles, activation) | delete | check / sync (consistency / synchronisation…

  • tia_umac_userwrite

    Project user (UMAC): create (password only from a file or environment variable), roles, comment, alias, activation, password change, delete.

  • tia_umac_usersread

    Project users, roles and rights (UMAC, TIA V17+) – read only.

Safety validation and F-parameters

Safety Validation Assistant (V21), activation tests, F-parameters of fail-safe modules.

  • tia_f_io_parametersread

    F-parameters (Failsafe_*) of fail-safe modules of a device or the whole project – consistency check with the F-CPU.

  • tia_safety_activation_testwrite

    Prepares a Safety Validation Assistant activation test (V21) from a specification; never confirms test results.

  • tia_safety_validationread

    Safety Validation Assistant (V21): activation tests, safety functions with conditions, test states, validity check.

  • tia_safety_validation_printoutread

    Printout of a Safety Validation activation test to a PDF file.

  • tia_set_f_io_parameterswrite

    Sets F-parameters (Failsafe_* only) of a fail-safe module; returns previous values.

HMI – connections, alarms and logging

WinCC Unified: HMI connections to PLCs, alarms, classes, logs, logging tags, runtime settings.

  • tia_hmi_unified_configread

    WinCC Unified beyond screens: HMI connections (incl.

  • tia_hmi_unified_config_setwrite

    Creates, changes or deletes a WinCC Unified object (connection, alarm, alarm class, log, logging tag, alarm audit class, OPC UA alarm type) with dotted property paths (connection driver properties as 'DriverProperties.<name>'); returns…

  • tia_hmi_unified_connect_plcwrite

    Creates an HMI connection to a PLC in the project.

  • tia_hmi_unified_logging_tagsread

    WinCC Unified logging tags (HMI tag → data log, mode, cycle, limits, smoothing).

  • tia_hmi_unified_runtime_settingswrite

    WinCC Unified runtime settings: read, or set with dotted paths; returns previous values.

Fingerprints and version control

Content fingerprints of blocks, VCI workspaces, export and synchronisation with files for Git.

  • tia_fingerprintsread

    Content fingerprints of blocks, UDTs and tag tables (V19+) per aspect; save a baseline and compare: code change vs.

  • tia_vci_exportwrite

    Maps PLC objects into a VCI workspace and writes them as files (SCL/DB/UDT, otherwise SIMATIC ML).

  • tia_vci_statusread

    State of mapped objects of a VCI workspace: equal / unequal / file missing and where the change is.

  • tia_vci_syncwrite

    VCI synchronisation: project → files or files → project (changes the project).

  • tia_vci_workspacewrite

    VCI workspace in the project: create (root folder e.g.

Git

Status, history, branches, merge, tags and push with a preview; never force, reset or rebase.

  • tia_gitwrite

    Safe git operations on the project text-export repo: status, log, branches, checkout, merge (no auto conflict resolution – aborted and reported), push (preview first, sent only with confirm=True), fast-forward pull, tags.

Block help

User-defined help for your own blocks (Shift+F1 in TIA) generated from code and an AI description.

  • tia_block_helpread

    User-defined help for blocks (Shift+F1 in TIA): an HTML page per block in UserFiles/UserDocumentation with interface, networks, call example and AI-written description; regenerates only changed blocks.

TIA → BAVIS (web SCADA)

Generates a ready BAVIS web SCADA project from TIA data blocks, UDTs and alarms: connections, addressed tags, objects, alarms and screens.

  • tia_bavis_exportread

    TIA → BAVIS (web based SCADA): generates a BAVIS project (JSON for Configuration → Project → Import) from the PLC: S7 connection for non-optimized DBs and I/Q/M tags with addresses computed from the DB layout, OPC UA for optimized DBs,…

Handover documentation

Handover PDF: architecture, blocks, I/O, alarms, review, fingerprints and changes since the last issue, protocol.

  • tia_handover_docread

    Software handover documentation (PDF/LaTeX with the Benešl Automation logo): project overview, hardware and IP addresses, call hierarchy, block descriptions (title, comment, interface, networks + AI texts), DBs and UDTs, I/O, HMI alarms,…

Diagnostics via CPU web server

Read-only S7-1500 Web API: operating mode, diagnostic buffer, alarms and values; trusted or pinned certificate.

  • tia_plc_web_diagread

    Online diagnostics of an S7-1500 via the CPU web server (Web API, read only): operating mode, diagnostic buffer, active alarms (FW V3.0+), variable values.

Live PLC values

Reading values, trends and writing to a running S7-1500 through the Web API; writing is off by default, with a preview and a token.

  • tia_plc_live_readread

    Current variable values from a REAL S7-1500 PLC via the CPU web server (Web API, read only): variables=['"DB_Process".LT1.rPV', ...] and/or db_name + device_name (all scalar members of the DB from the project, max 200).

  • tia_plc_live_trendread

    Records the course of variables from a REAL PLC (Web API, read only): periodic reading every interval_s (min 0.2 s so the CPU is not loaded) for duration_s (max 3600 s).

  • tia_plc_live_writewrite

    Writes values to a RUNNING REAL PLC (Web API) – disabled for the agent until the user turns on the switch "Agent may write values to a running PLC" in the web GUI (Dashboard; the default without the switch comes from…

Hardware – modules

Free slots, moving and copying modules, swapping for another type while keeping the configuration, module description.

  • tia_change_module_typewrite

    Replaces a module / CPU with a compatible type or another firmware version while keeping the configuration (DeviceItem.ChangeType) – e.g.

  • tia_move_modulewrite

    Moves (or with copy=True copies) a module to another rack position – also into another device (target_device); parameters and addresses go with it.

  • tia_plug_locationsread

    Rack slots of a device (read only): occupied positions (module, TypeIdentifier, path) and free positions (GetPlugLocations) – basis for tia_plug_module / tia_move_module.

  • tia_update_module_descriptionwrite

    Updates module descriptions (ModuleDescriptionUpdater – a newer HSP/GSD revision in the catalog).

HMI – Unified lists, scripts and tags

Text and graphic lists, global script modules, native tag export and import, limits, screen groups, rescaling to another resolution, validation, dynamizations and plant views.

  • tia_hmi_unified_add_dynamizationwrite

    Dynamization of an item property of any kind: script (with trigger: cycle, tags, custom cycle; SyntaxCheck in the result), expression (formula), flashing (colors, rate, condition – color properties only), resource_list (text/graphic list…

  • tia_hmi_unified_attribute_inforead

    Which attributes of a WinCC Unified object can be written (GetAttributeInfos → AccessMode), current values, compositions and actions.

  • tia_hmi_unified_export_tagsread

    Native YAML export of WinCC Unified HMI tags per tag table (out_dir/<table>/…).

  • tia_hmi_unified_import_listswrite

    Imports text / graphic lists from YAML (files from tia_hmi_unified_lists out_dir or edited by hand); a list with the same name is overwritten.

  • tia_hmi_unified_import_script_moduleswrite

    Imports global script modules from a folder (export of tia_hmi_unified_script_modules) or one module from text (module + code).

  • tia_hmi_unified_import_tagswrite

    Imports HMI tags from YAML (format of tia_hmi_unified_export_tags) – each file into `table`, otherwise into the table named like the file; existing tags are overwritten, new ones created.

  • tia_hmi_unified_listsread

    WinCC Unified text, graphic (V21) and system text lists: kind = text | graphic | system | all.

  • tia_hmi_unified_plant_viewsread

    Plant views (WinCC Unified V21, Cpm.PlantViewsProvider): views, assigned HMI and the node tree with plant objects.

  • tia_hmi_unified_replace_in_script_moduleswrite

    Find and replace in the code of global script modules (export → replace → import of the changed modules only, backup of the original export, check of remaining matches).

  • tia_hmi_unified_resize_screenswrite

    Rescales Unified screens to the panel resolution (HmiScreen.ResizeScreen): resolution ('1280x800') first changes the device resolution (runtime settings), then screens and items are scaled by the ratio of old and new resolution (without a…

  • tia_hmi_unified_screen_groupsread

    WinCC Unified screen groups (tree) with their screens and the root screens.

  • tia_hmi_unified_script_modulesread

    Global script modules of WinCC Unified (HmiSoftware.Scripts): names and functions; include_code=True returns the JavaScript; out_dir stores the native export (<module>.hmi.yml + .js, git-friendly).

  • tia_hmi_unified_set_listwrite

    Creates or overwrites a WinCC Unified text (kind=text) or graphic (kind=graphic, V21) list – Openness has no Create, so YAML is generated and imported – or deletes it (delete=True).

  • tia_hmi_unified_set_plant_viewwrite

    Plant views (V21): create_view | rename_view | delete_view | assign_hmi | create_node (path 'Area/Unit', creates intermediate nodes) | rename_node | delete_node.

  • tia_hmi_unified_set_screen_groupswrite

    Unified screen groups: create_group (path 'A/B') | rename_group | delete_group (only empty) | create_screen (new screen in a group).

  • tia_hmi_unified_set_tag_tableswrite

    Groups and tables of Unified HMI tags: create_group (path 'A/B') | rename_group | delete_group | create_table (optionally in a group) | rename_table | delete_table (only empty).

  • tia_hmi_unified_set_thresholdswrite

    Edits the thresholds of a numeric Unified HMI tag: the two fixed thresholds (Upper / Lower Threshold) are selected by index, name or mode and get a value (value type Constant / Tag is set automatically).

  • tia_hmi_unified_tag_detailsread

    Details of a Unified HMI tag: all properties incl.

  • tia_hmi_unified_tag_tablesread

    WinCC Unified tag tables including tables in tag table groups, with tag counts and the group tree; optionally the system tags.

  • tia_hmi_unified_validateread

    Validation of WinCC Unified without compiling: Validate() of screens, items, tags, connections, alarms and runtime settings plus SyntaxCheck() of scripts (dynamizations and events).

HMI – fixes after Comfort → Unified migration

Symbol library objects to dynamic SVG widgets, truncated texts and characters in alarm texts.

  • tia_hmi_migrate_symbol_librarywrite

    Converts Comfort/Advanced "Symbol library" objects (after the TIA migration empty GraphicViews without a foreground color) into WinCC Unified dynamic SVG widgets.

  • tia_hmi_unified_fit_textswrite

    Texts that do not fit after a Comfort→Unified migration and end with "…" (buttons, text fields, labels): measures the text in the runtime language (runtime_language, e.g.

  • tia_hmi_unified_fix_alarm_textswrite

    Fixes double-escaped characters in WinCC Unified alarm texts after a migration (runtime shows "--&gt;" instead of "-->"): '&amp;gt;' → '&gt;', also &amp;lt; &amp;amp; &amp;quot; &amp;#NNN; – discrete and analog alarms, all languages,…

HMI – Comfort and migration

Complete export and import of Comfort panels (screens, lists, connections, cycles, VB scripts) for migration and versioning.

  • tia_hmi_comfort_exportread

    Exports one classic WinCC object as SimaticML: kind = screens | templates | popups | slideins (name = Top/Bottom/Left/Right) | tag_tables | text_lists | graphic_lists | connections | cycles | vbscripts | global_elements | overview |…

  • tia_hmi_comfort_importwrite

    Imports one SimaticML object into classic WinCC (override): the kind is detected from the XML; an existing object is replaced in its folder, a new one goes to folder ('A/B', created).

  • tia_hmi_comfort_import_allwrite

    Re-imports an export from tia_hmi_comfort_export_all (manifest.json, otherwise by subfolders) in the right order: graphics → lists → cycles → tags → VB scripts → templates → global elements → screens → pop-ups → slide-ins → overview.

  • tia_hmi_comfort_objectsread

    Inventory of classic WinCC (Comfort/Advanced): screens, templates, pop-ups, slide-ins, tag tables, text and graphic lists, connections, cycles, VB scripts, global elements, screen overview, project graphics – names and folders.

  • tia_hmi_comfort_text_listwrite

    Text list of classic WinCC (Comfort) – creates or replaces it via SimaticML: entries = {"0": "Stop", "1": "Run", "2-5": "Range"} or a list with value / from-to / default and texts per language; list_range = Decimal | Bit | Binary; culture…

  • tia_hmi_comfort_vbscriptwrite

    VB script of classic WinCC (Comfort/Advanced) – creates or replaces it via SimaticML: code, script_type = Sub | Function, precode, user folder.

HMI – simulation and screenshots

What the PC offers for runtime and simulation, preparing the HMI for simulation and a screenshot plan built from the navigation.

  • tia_hmi_runtime_prepareread

    Prepares an HMI for simulation/runtime: compiles the HMI device (Unified panel/PC and Comfort; ICompilable on the device), returns errors plus 'blockers' Openness cannot fix (empty password in Runtime settings of a new Unified device in…

  • tia_hmi_runtime_statusread

    What this PC offers for HMI runtime/simulation: WinCC Unified PC runtime (version, install type – e.g.

  • tia_hmi_unified_screenshot_planread

    Screenshot plan for WinCC Unified built from the project: start screen (Runtime settings), navigation buttons (ChangeScreen in event scripts + button text in language lang) and screens shown in screen windows → click order through all…

HMI – automated test in simulation

A test plan from the WinCC Unified project and its run against the simulation and PLCSIM Advanced: navigation, buttons, I/O fields and alarms, a report with screenshots of failures.

  • tia_hmi_test_planread

    Plan of an automatic WinCC Unified HMI test built from the project (read-only): nav = navigation buttons (after the click the texts of the target screen are visible), button = buttons whose event writes a constant to a PLC tag…

  • tia_hmi_test_runwrite

    Automatic WinCC Unified HMI test against a SIMULATION: a browser (Playwright) drives the Unified runtime web client on this PC (url, default https://localhost/WebRH; login user + password_file / password_env) and checks and sets values in…

HMI runtime & screenshots

Starting and stopping the WinCC Unified simulation with confirmation, and screenshots of the screens for the manual straight from the running simulation.

  • tia_hmi_runtime_controlwrite

    Starts / stops / reports the state of a WinCC Unified PC runtime SIMULATION via the SIMATIC Runtime Manager CLI (no window): action = state (read-only) | start | stop.

  • tia_manual_screenshotsread

    HMI screen screenshots for the operating manual (data.json from tia_manual_collect) – also afterwards, when the simulation is started only after data collection.

Commissioning – extended

Transactions with rollback on error, download to a folder or card, .psc files, DB value snapshots, online connection and R/H status.

  • tia_db_load_valueswrite

    Writes ACTUAL values of data blocks into the running PLC (TIA V21 ValueService): source = snapshot (snapshot from the project) | start_values.

  • tia_db_snapshotwrite

    Snapshot of the ACTUAL values of data blocks (TIA V21 ValueService): create=True connects to the PLC, stores the actual values as a snapshot in the project and returns them (the members' 'Snapshot' attribute; out_dir also saves a JSON).

  • tia_download_to_folderread

    Downloads the PLC (HW + SW) into a FOLDER instead of a device – image for a SIMATIC Memory Card (S7_JOB.S7S, SIMATIC.S7S).

  • tia_export_pscread

    Exports the PC station configuration to a .psc file for the SIMATIC card reader (PC systems: Software Controller, Open Controller, IPC with applications).

  • tia_online_connectread

    Online connection to a CPU answering the login dialogs: address = CPU IP address (TIA V21 GoOnline(ConfigurationAddress)), access-level password / user login only via password_file / password_env, the PLC TLS certificate is reported…

  • tia_rh_statusread

    State of an S7-1500R/H redundant system (RHOnlineProvider): primary and backup CPU state and PC interfaces; probe=True briefly connects to both CPUs (optionally to given IPs) and disconnects.

  • tia_transaction_runwrite

    Atomic batch: runs steps [{tool, args}] inside ONE TIA transaction (TIA V16+, ExclusiveAccess + Transaction).

Drives – commissioning

Startdrive: motor data and motor codes, function modules, security, the safety acceptance test report, online actions and DCC charts.

  • tia_drive_commissioning_inforead

    What Startdrive offers on a drive via Openness (DFI): third-party motor/encoder configuration incl.

  • tia_drive_dccread

    DCC (Drive Control Chart) of a drive: charts, DCB libraries and block types, chart content (blocks, pins, values) and export to a file.

  • tia_drive_dcc_editwrite

    Edit DCC: create a chart, add a DCB block, connect pins, set a pin value, import a chart exported by tia_drive_dcc, delete a chart.

  • tia_drive_functionswrite

    Drive object functions: activate/deactivate function modules (basic positioner EPOS, technology controller PID) and Safety axis type on 3rd-generation drives, drive object activation (S120), drive object type, Safety checksum update and…

  • tia_drive_motorwrite

    Offline motor setup of a SINAMICS drive: motor type, rated data (p304–p311 – the only Openness path to these parameters), Siemens motor code, SIMOGEAR MLFB and third-party encoder; returns before/after values with read-back verification.

  • tia_drive_onlineread

    Online drive (Startdrive online): status and parameters read directly from the drive; an offline drive returns NotOnline.

  • tia_drive_online_actionwrite

    Online actions on a drive: copy RAM to ROM for all drive objects, or factory reset (only with confirm=True on explicit user request).

  • tia_drive_safety_acceptancewrite

    Safety Integrated acceptance test of a drive (TIA V21): select/deselect test functions (STO, SS1, SLS…), reset the selection and write the test protocol to a file.

  • tia_drive_securitywrite

    Security of 3rd-generation SINAMICS drives (S200, S210 6SL5, G220): switch user management (UMAC) and drive data encryption (DDE, needs a password that is never stored or logged).

Motion

Cams, interpreter programs and their mappings, connecting technology objects to hardware.

  • tia_cam_exportread

    Exports a TO_Cam (S7-1500T) as MCD segment table (with points), Scout, point list or binary file.

  • tia_cam_importwrite

    Imports cam data into a TO_Cam from points [[x, y], …] or a file (x/y point table, MCD, Scout, binary); verified by re-export.

  • tia_interpreter_exportread

    Source text of an interpreter program (TO_InterpreterProgram, S7-1500T), optionally saved to a file.

  • tia_interpreter_importwrite

    Loads an interpreter program (TO_InterpreterProgram) from text or a file and verifies it by re-export.

  • tia_interpreter_mappingswrite

    Interpreter mappings (TO_InterpreterMapping, TIA V21): alias → technology object, alias → DB member; add, remove and list.

  • tia_motion_objectsread

    PLC technology objects including measuring inputs, output cams and cam tracks below axes: type, version, axis and available Openness services (cam data, HW connection, interpreter, couplings).

  • tia_to_hw_connectwrite

    Hardware connection of a measuring input, an output cam / cam track or a TO_Ident: output PLC tag (cam on a standard DQ), bit address (%I0.3 / %Q1.2) or module and channel only on suitable hardware (TM Timer DIDQ …; plain DI/DQ are…

Safety – administration

The official collective F-signature from TIA V21, the F-program password and the F-I/O status block.

  • tia_safety_adminwrite

    Safety Administration of an F-CPU (write).

Libraries – maintenance

Version comparison, a check for outdated instances, harmonization, clean-up, master copies and archiving of the global library.

  • tia_global_library_managewrite

    User global library as a file: create, save, save_as (copy into folder target_dir – the library takes the folder name and the open library switches to the copy), archive (compressed / none / discard restorable data), close (with unsaved…

  • tia_library_compareread

    Library comparison (TIA V21, CompareToLibrary): library (None = project library, otherwise an open global library) against target_library ('project' / global library name).

  • tia_library_create_master_copywrite

    Creates a master copy from a project object (MasterCopyComposition.Create): block, data_type, tag_table, watch_table, device, hmi_screen, hmi_tag_table (Comfort).

  • tia_library_maintainwrite

    Library maintenance (project or open global library; selection type_names / folders, none = whole library).

  • tia_library_update_checkread

    Update check (UpdateCheck): which type instances in the project are not on the current version of the library (None = project library, otherwise an open global library).

PLC – checksums and extras

Checksums, a software comparison of two PLCs, linked tags, the process image, write protection, instance DBs and alarm texts.

  • tia_block_write_protectionwrite

    Write protection of a block (TIA V21 PlcBlockWriteProtectionProvider; the block can still be read but not changed).

  • tia_compare_plc_softwareread

    Offline comparison of a PLC program with another PLC (PlcSoftware.CompareTo, like TIA Compare offline/offline): blocks, UDTs, tags… only left / only right / different.

  • tia_create_instance_dbwrite

    Creates an instance DB for an FB (PlcBlockComposition.CreateInstanceDB).

  • tia_linked_tagsread

    Which PLC tags sit on the I/O channels of the modules (TIA V21 PlcTagProvider.GetLinkedTags): channel → tags (name, address, table).

  • tia_plc_alarm_textlistsread

    PLC alarm text lists (user and system: name, ID, range, comment).

  • tia_plc_checksumsread

    Offline PLC checksums (PlcChecksumProvider: Software and TextLists – the CPU shows the same values online; equal = this program is in the PLC) and block metrics (TIA V21: load/work memory size, download, compile and code change date).

  • tia_process_imagewrite

    Process image of a module (TIA V21): without parameters only reads the addresses and their partition.

  • tia_prodiag_block_inforead

    Exports the ProDiag information of a compiled ProDiag FB to a folder (CodeBlock.ExportProDIAGInfo – basis for HMI/documentation of supervisions).

  • tia_project_text_categoriesread

    Categories of project texts (TIA V21 Project.TextCategories: block comment, alarm text…) for the filtered export tia_export_project_texts(categories=…, devices=…).

  • tia_virtual_plc_compilewrite

    Project setting 'support virtual PLC during block compilation' (TIA V21 VirtualPlcSettingsProvider).

Project – identity and settings

Object IDs, project history and archiving, TIA Portal information, diagnostic settings, the PLC web server and display logo, telecontrol.

  • tia_custom_identitywrite

    Custom key–value pair stored in the project on a device or module (CustomIdentityProvider) – e.g.

  • tia_diag_settings_exportread

    Exports the project's diagnostics settings to .dat: 'prodiag' (ProDiag supervision settings) and 'sysdiag' (system diagnostics – classes and texts of messages).

  • tia_diag_settings_importwrite

    Imports diagnostics settings into the project: kind = 'prodiag' | 'sysdiag', path = .dat from tia_diag_settings_export.

  • tia_module_inforead

    HW catalog (ModuleInformationProvider): all versions of an article number ('OrderNumber:6ES7 521-1BH00-0AB0'), and with a version ('…/V2.2') also the racks / devices the module fits into (e.g.

  • tia_object_idread

    Stable ID of a project object (ObjectIdentifierProvider) – survives renaming and moving; useful for links from external tools (EPLAN, tickets, Git).

  • tia_plc_display_logowrite

    Custom logo on the display of an S7-1500 CPU (FrontPanelDisplay): without parameters only reads the settings.

  • tia_plc_webserverwrite

    CPU web server: without parameters only reads (Webserver* attributes, web server access to watch/force tables, V21 web applications and system pages).

  • tia_portal_inforead

    The TIA Portal installation the server is connected to: products and optional packages with versions (Startdrive, Safety, Test Suite…), attached Openness sessions, Multiuser servers and TIA settings (read-only).

  • tia_project_archiveread

    Archives the project (.zap21…) into a folder – backup before bigger changes or for hand-over.

  • tia_project_historyread

    Project history (creation, migration, upgrade, mass imports… with time), products used by the project and which of them are missing on this PC (compared with the installed TIA).

  • tia_telecontrol_datapointsread

    TeleControl data points of a CP in the station (CP 1243-1 TeleControl Basic…, TelecontrolManagement): TeleControl communication state, protocol, data points (name, type, index, cycle).

  • tia_telecontrol_importwrite

    TeleControl CP data points: csv_path = import CSV (format of the tia_telecontrol_datapoints export), tags = new data points from PLC tags (names), activate = switch on TeleControl communication of the CP, replace=True deletes the existing…

Offline help

Search in the bundled TIA-MCP documentation without internet – for local models and offline operation.

  • tia_docs_searchread

    Searches the bundled TIA-MCP documentation (README, docs/*.md) – works without internet and without TIA.

Long-running background jobs

Importing dozens of sources, compiling large PLCs and HMIs and saving in a separate process that survives a server restart; job status and cancellation.

  • tia_worker_runwrite

    Long-running operation in a separate process (worker) – survives an MCP server restart and the server does not hang meanwhile: tools calling Openness immediately return TiaBusy with the job id, tia_job_status / tia_job_cancel /…

Core, safeguards and project

TIA connection, status, snapshots and restore, plans with approval, write mode, search, diagnostics.

  • close_projectwrite

    Close the project. With unsaved changes it refuses unless save=True or discard_changes=True (only on explicit user request).

  • connect_to_tiaread

    Connects to a running TIA Portal instance: by PID, or by (part of) the project name (project_name, case-insensitive); with neither, connects to the first one found.

  • create_projectwrite

    Creates a new empty project in the connected TIA Portal instance (Projects.Create) and leaves it open.

  • get_project_inforead

    Information about the open project.

  • get_running_tia_instancesread

    List of running TIA Portal instances (PID, mode, project).

  • open_projectread

    Opens a project (.ap20 etc.) in the connected instance.

  • save_projectwrite

    Save the project (persists all changes – save only after the user agrees).

  • tia_activate_licenseread

    Activates a TIA-MCP license: license key BA-LIC-… (offline) or order code BA-ORD-… (online via the Benešl Automation license portal – issues a license for this PC's Hardware ID).

  • tia_build_indexread

    Builds/updates the project's full-text index (blocks: SCL/pseudologic/interface, PLC tags, UDT, Unified screens).

  • tia_call_toolread

    Calls any TIA-MCP tool by name, also one hidden by the active profile, with the same safeguards (write lock, snapshots, read-only mode).

  • tia_check_namesread

    Checks variable names against the naming convention.

  • tia_doctorread

    Environment diagnostics without touching the project: Python and pythonnet, TIA and Openness installation, the “Siemens TIA Openness” group, privilege level, running TIA and connection, licence, write mode, disk space, writable logs and…

  • tia_find_toolsread

    Searches all TIA-MCP tools (also those hidden by the active profile) by keywords; hidden ones are called via tia_call_tool.

  • tia_get_conventionsread

    Returns the project conventions (naming, languages, libraries, write safety) from docs/CONVENTIONS.md.

  • tia_get_license_inforead

    Returns Benešl Automation license information, Hardware ID (HWID), activation status and remaining trial quota.

  • tia_get_statusread

    Server status: connection to TIA, open project, Openness version, write mode, number of snapshots, license.

  • tia_job_cancelread

    Requests cancellation of a running job (it will finish the current step).

  • tia_job_statusread

    Status of a background job (without job_id, a list of all).

  • tia_list_snapshotsread

    List of automatic snapshots (backups taken before a write), newest first.

  • tia_list_toolsetsread

    Active tool profile and hidden tools. Profiles (full|plc|hmi|hmi_config|docs|readonly|sim|commissioning|security|migration|drives|local|local_write|copilot) are set in .env (TIA_MCP_PROFILE / TIA_MCP_TOOLSETS, "+tia_xxx" adds and…

  • tia_plan_approveread

    Approves the plan. Call ONLY after the user has explicitly approved the plan in the chat.

  • tia_plan_createread

    Creates a plan for a multi-step change. steps = [{"tool": "<MCP tool name>", "args": {...}, "note": "..."}].

  • tia_plan_discardread

    Discards the plan.

  • tia_plan_executeread

    Executes an approved plan step by step (every write step goes through a snapshot and an audit).

  • tia_plan_listread

    List of plans (optional filter: draft|approved|running|done|failed|discarded).

  • tia_plan_showread

    Readable overview of the plan – show it to the user for approval.

  • tia_project_overviewread

    Compact summary of the open project: PLCs (block counts by type/language, F-CPU, inconsistent blocks, folders, tag tables, UDTs), HMIs (Unified/Comfort, screens), other device types.

  • tia_prune_snapshotswrite

    Clean up old snapshots: deletes those older than max_age_days but keeps keep_min newest per project.

  • tia_read_snapshotread

    Returns the XML content of a snapshot (the object's state before the write).

  • tia_restore_snapshotwrite

    Restores an object from a snapshot (undoes a write).

  • tia_searchread

    Full-text search via the index (tia_build_index): FTS5 syntax ('ventil*', '"FB_AI" AND limit', 'name:FB_*'), falls back to LIKE on a syntax error.

  • tia_set_write_moderead

    Switch write mode: 'read_only' (no tool may change the project) or 'write'.

  • tia_ui_dialogsread

    Dialogs open in TIA Portal that block Openness; can close informational ones (Export/Import Completed).

  • tia_where_usedread

    Where a symbol (tag, DB, block, #variable) is used – via the index (fast, offline).

Error reports to the vendor

Recorded unexpected errors and a report with a preview before sending – anonymised, without the project or PLC data.

  • tia_error_reportsread

    Unexpected TIA-MCP errors recorded on this PC (logs/errors.jsonl, anonymised): when, tool, type, message, traceback and a summary per tool.

  • tia_openness_quarantineread

    Places where TIA Portal crashed while reading via Openness (device, screen, object and step: properties, text, dynamizations, events).

  • tia_report_problemread

    Report a problem or error in TIA-MCP to the vendor (Benešl Automation).

Licence and updates

Licence activation, checking and installing signed updates, rollback.

  • tia_license_deactivatewrite

    Releases the license of this PC on the license portal (moving to another computer) and removes it here.

  • tia_update_checkread

    Checks for a new TIA-MCP version (vendor-signed manifest; at most once a day, force=True now): current/latest version, changelog, whether license maintenance covers it.

  • tia_update_installwrite

    Downloads and installs the new TIA-MCP version (vendor signature check, backup, license/settings preserved).

  • tia_update_rollbackwrite

    Restores TIA-MCP to the version before the last update (from the backup in backups/).

Tool names are technical identifiers seen by the AI agent. Clients with a tool limit (e.g. Copilot in VS Code – 128) use profiles: plc, hmi, docs, commissioning, readonly or sim.