How-to
Learning advanced HMI features from demo projects
Short answer
Skip the search for one advanced course. Pick the capability you cannot reproduce, open the vendor's demo project for it, rebuild it in a clean test project, and pass the acceptance set before it becomes your internal standard. One demo per capability covers macros, database read/write, historical graphs, dashboards and remote access.
On this page
- The method: one demo project per capability
- Start from the capability you cannot reproduce
- Where the official material comes from
- Proving a macro in a clean project
- Testing database read/write and history as separate paths
- Validating dashboards and remote access end to end
- Worked example: a five-capability pass with five demo projects
- Turning the passes into an internal standard
- Questions asked
You do not need an advanced course to master macros, database read/write, historical graphs, dashboards or remote access on an operator panel. The training platform already exists: the manufacturer's manuals, videos and demo-project library. The method is narrow and it works: pick the one capability you cannot reproduce without trial and error, rebuild its official demo in a clean test project, pass a fixed acceptance set, and store the result as your internal standard. Repeat once per capability. Five capabilities, five demo projects, five standards, each one proven on the bench before it touches a machine.
The method: one demo project per capability #
One capability at a time, one official demo project each, rebuilt and tested in a clean project before it earns a page in the internal standard. Run the loop like this:
- Write down the advanced capabilities you cannot reproduce on demand. For panels in this class the list reads: macros, database read/write, historical graphs, dashboard deployment, remote access.
- Pick one capability and open the vendor's demo project for it.
- Before the first download, list every dependency the demo carries: tags and device addresses, external services, ports, accounts, network paths.
- Rebuild the demo in a blank project rather than only running the download. Running it proves the vendor's example; rebuilding proves you.
- Run the acceptance set on your rebuild: normal input, boundary input, invalid input, lost communication, restored communication, project restart.
- Record the passing configuration, the dependency list and the naming rules as one entry of the internal standard.
- Move to the next capability only after the current one passes all six tests in the clean project.
Start from the capability you cannot reproduce #
Diagnose before you study. The feature you cannot reproduce is the training unit; a general course covers everything and fixes nothing in particular. Typical readings:
- Standalone projects work but larger ones drift: no standard structure or acceptance checklist.
- Macros work in one project only: hidden dependencies and unclear data ownership.
- Database writes succeed but records cannot be trusted: read-back and failure handling never tested.
- Live values look right but history is wrong or short: logging, timestamps and retrieval not validated together.
- The dashboard works locally but not where people use it: deployment and network dependencies left implicit.
- Remote access is unreliable: it was treated as a screen feature instead of an end-to-end network service.
Decision: one failing feature sends you to that feature's demo project. Several features failing differently across projects means you build the resource baseline first.
Where the official material comes from #
Collect the manufacturer's manuals, videos, sample applications and demo projects for the capabilities in scope; account registration is normally all that stands between you and the download library. Your distributor is the primary contact for product documentation and application help, and vendor support forums answer specific questions in depth. Reusable building blocks belong to documented sources across controls work, the same discipline as selecting part macros from official component data. An AI assistant familiar with the vendor's free editing software will shortcut syntax questions, but its output goes through the same rebuild and the same acceptance set as everything else.
Proving a macro in a clean project #
A macro is reusable only when another engineer can state when it executes, which data it changes, and what result proves completion. Anything less is a project-private script. Prove it in the smallest project that holds the macro and its data:
- Exercise normal input, boundary input and invalid input.
- Watch every value the macro writes and confirm unrelated values stay unchanged.
- Fire the trigger twice to expose retained state and unintended repeated actions.
Decide data ownership before writing logic: HMI-entered values that must survive a power cycle belong in retained PLC memory, the discipline behind how to keep HMI-entered timer presets in PLC memory. If the isolated macro passes but the integrated one fails, inspect trigger order and shared data before rewriting the logic. The trigger-versus-program question is older than panels; robot cells face the same choice, covered in macros versus standard teach programs on robots.
Testing database read/write and history as separate paths #
A successful write proves nothing about reading the record back, stamping it with the right time, or displaying it in a graph. Run two proofs, in order.
Database proof: write a known test value, read it back through the screen's own query path, and compare. Then interrupt the connection mid-transaction and record what actually happens: report, retry, queue or silent loss.
- Write and read-back pass: continue to the history proof.
- Write passes, read-back fails: check the query, field mapping, data type and selected record.
- No transaction completes: check connectivity and database-side permissions before touching screen objects.
- Recovery duplicates or loses data: stop deployment and define transaction ownership.
History proof: inject a recognizable sequence of values and confirm the stored sequence, the retrieved sequence, the displayed order and the time basis all agree. Live values correct while history is wrong points at the logging or retrieval path; changing the graph's appearance fixes nothing.
Validating dashboards and remote access end to end #
A dashboard spans the panel project, its data source, the network path and the viewing endpoint, so take readings at each boundary: the panel shows the expected live value, the dashboard shows the same value and state, and the dashboard reaches the place people actually work. Pull one dependency at a time, data source then network path, and record the visible failure indication. Wrong locally: stay in the tag or device-communication layer. Right locally but wrong on the dashboard: mapping and update behavior. Right in both but unreachable remotely: network and remote-access diagnostics. Multi-machine sites add wiring and addressing limits of their own, the territory of connecting multiple HMIs to one PLC over long serial runs.
Commission remote access as its own item: configuration, service state, network reachability, accounts and the target panel's identity, verified over the real network path rather than assumed from a working local project. Keep the panel behind the plant network or a VPN, never forwarded straight to the internet, and leave machine safety functions under local control.
Worked example: a five-capability pass with five demo projects #
Inputs, each with its source:
- Capabilities in scope: 5, namely macros, database read/write, historical graphs, dashboards, remote access. Source: the reader's own list.
- Demo projects per capability: 1. Source: the method in this article.
- Input classes per macro pass: 3, namely normal, boundary, invalid. Source: the macro proof above.
- Repeated trigger per macro: 1, to expose retained state. Source: the macro proof above.
- Acceptance tests per capability: 6, namely normal input, boundary input, invalid input, lost communication, restored communication, project restart. Source: the acceptance set in step 5.
Rule in words: reproductions equal capabilities times demo projects each; macro executions equal input classes plus the repeated trigger; recorded acceptance results equal capabilities times tests; standard entries equal capabilities times one entry each.
The arithmetic:
- 5 capabilities × 1 demo project = 5 reproductions.
- 3 input classes + 1 repeated trigger = 4 executions before the macro is trusted.
- 5 capabilities × 6 acceptance tests = 30 recorded results.
- 5 capabilities × 1 standard entry = 5 entries.
Result: five reproductions, 30 recorded acceptance results and five standard entries cover the full scope from standalone machines to networked architectures.
Decision: a capability enters the internal standard only when its reproduction passes all six tests in the clean project; below that it stays on the bench and off production machines. Five passes with zero failures completes the standard for this scope. If a capability needs a second demo, and remote access usually also needs a working communication demo first, the count rises above five: five is the floor for this list, not a cap.
Turning the passes into an internal standard #
- Define the project structure and naming rules once, for every project.
- Store one proven example per capability: macro, database read/write, historical graph, dashboard, remote access.
- List every external dependency next to the check that proves it is available.
- Keep the six-test acceptance set as the deployment gate.
- Run the gate on a clean download, never only on the development copy.
- Version the standard and its example projects like any other program deliverable.
When a new panel model or editor version arrives, rerun the acceptance set; a pass under the old version is not evidence under the new one.
Questions asked
Do I need a paid course to reach advanced HMI skills?
No. The manufacturer's manuals, videos and demo projects cover the same material at your own pace. Spend the budget on bench hardware instead: a small panel, a switch and a test database let you exercise remote access and multi-machine behavior away from production. A course buys schedule, not content.
Why rebuild the demo in a clean project instead of just running it?
Running the download proves the vendor's example under the vendor's assumptions. Rebuilding it forces you to find every tag, service and setting the demo silently depends on. Keep the untouched original as a reference copy, so you can compare against it whenever your rebuild behaves differently.
Can I learn from a related brand's samples when the software shares a lineage?
Use them as extra examples only. Related brands can behave differently on specialized applications even when the editor looks the same. Treat any behavioral difference as a reason to retest on your own brand, never as proof that an identical configuration transfers.
How do I test the failure path of a database connection?
Write a known value, read it back through the screen's own query, then interrupt the link mid-transaction and watch the project. Deploy only when it reports or retries the failure; if it silently loses or duplicates records, transaction ownership is still undefined and the integration is not ready.
How do I keep remote access from becoming a security problem?
Commission it as its own item: verify configuration, service state, reachability and the target panel's identity over the real network path. Give each user an individual account with their own password, and disable accounts the day someone leaves the project. Leave the panel reachable only through the plant network or an approved VPN.