IMDHMIControls LibraryShop main store

How-to

How to learn PLC, SCADA and DAQ from scratch

SCADA and data logging Published 7 min read

Short answer

Learn the three as one project, not three courses: pick one route, wire one real input, program a three-state sequence, exchange one Modbus register, bind SCADA tags and store a timestamped value. Pass the five checkpoint tests on the way; simulation alone never exercises terminals, polarity or reconnection.

On this page
  1. Pick one route and one small project
  2. Wire one real input and one visible output
  3. Program a three-state sequence in ladder
  4. Exchange one Modbus register
  5. Bind SCADA tags and log a timestamped value
  6. Worked example: taking one temperature register from raw word to degrees Celsius
  7. Grow the slice, not the subject list
  8. Questions asked

Learn PLC, SCADA and DAQ as one project, not three courses. Pick one route, follow one signal through the whole chain — field device, input channel, PLC logic, communication, SCADA screen, database — and pass five checkpoint tests on the way. That single vertical slice teaches what isolated study cannot: when the number on the screen is wrong, you know which layer broke. Start in the CODESYS simulator today, wire a real 24 VDC input as soon as you have hardware, and leave SCADA binding until the layers below it have passed their tests. Simulation alone never exercises terminals, polarity or reconnection, and that is exactly where real commissioning time goes.

Pick one route and one small project #

Three workable routes exist for a first build. Choose one and finish the project on it; switching routes mid-project teaches nothing.

Route Environment What it teaches What it cannot teach
Software-only CODESYS simulator with its built-in visualization Scan behavior, ladder and structured text, screen tag binding Terminals, field power, wiring and electrical faults
Integrated hardware S7-1200 programmed with TIA Portal Basic The same languages plus real I/O wiring in one engineering tool Installation practice until you wire it; onboard I/O varies by CPU
Low-cost prototype OpenPLC on an Arduino-class board, pymodbus client in Python Ladder basics and a real Modbus exchange Behavior of commercial controllers and industrial installation practice

If you know which platform your target employers run, learn that one, because interviews test the environment you know. Otherwise start software-only today — the simulator needs no hardware — and add an S7-1200 when you can. Choose a CPU whose datasheet lists both digital and analog channels onboard, so your analog work needs no add-on module.

Define the first project now and keep it to one signal: read a temperature input, apply an alarm threshold, show the value, record it. Write the signal path on paper before any configuration — sensor, input terminal, PLC variable, scaled value, alarm, SCADA tag, database column, one name in each. Checkpoint 1 passes when that written path exists.

Wire one real input and one visible output #

Simulation proves logic, never installation. A mismatched electrical signal shows up at this step, and software cannot repair it. One safety note for the whole build: verify supply voltage and polarity with a meter before energizing, and keep the first circuit simple enough to trace terminal by terminal.

  1. Read the controller and I/O documentation for supply voltage, channel type, terminal assignment and the permitted signal range; do not copy terminal numbers from a similar-looking module.
  2. Power a 24 VDC controller variant from a suitable 24 VDC supply, polarity confirmed before switch-on.
  3. Wire one input device and one visible output device from a learning-electronics kit — a switch and a lamp are enough.
  4. Measure the field signal at the input terminal, then compare it with the raw value the PLC reports.
  5. For an analog signal, build the engineering-unit range from the sensor and input documentation, and set alarm limits only after scaling checks out.

Checkpoint 2 passes when the PLC input status follows the physical device, the measured signal sits inside the documented channel range, and the output follows a manual test command.

Program a three-state sequence in ladder #

Write the first sequence in ladder, because the contact-and-coil view keeps permissives, interlocks and output conditions visible on one page. Add function block for signal processing and structured text for calculations once the sequence runs.

  1. Implement three states only: idle, run, controlled stop.
  2. Create named variables for the physical input, scaled process value, command, permissive, alarm and output.
  3. Map physical I/O in one place, and keep the logic independent of raw hardware addresses so the simulator and the hardware run the same code.
  4. Define failure behavior: when a permissive drops, outputs go to their designed condition; an alarm clears only when its initiating condition is gone.
  5. Test normal operation, boundary values, a disconnected input and a lost communication source — all before any SCADA command exists.

The PLC owns the interlocks. An HMI or SCADA command is a request that PLC logic approves or rejects; driving an output directly from a screen tag bypasses every control condition and is wrong practice wherever you meet it.

Checkpoint 3 passes when the sequence reaches every defined state, a command with a false permissive is rejected, and outputs land in their designed condition on input or communication failure.

Exchange one Modbus register #

Modbus is the right first protocol, because one client asks, one server answers, and everything about the exchange is documented. A MAX485 transceiver supplies only the RS-485 electrical layer; it says nothing about what a register means. That comes from the device's register map.

  1. Decide the first link — serial through MAX485 or a network link — and write the choice down.
  2. Copy baud rate, parity, stop bits, device address and register definitions from the device documentation. Settings that look plausible but were guessed anyway are the most common first fault.
  3. Configure pymodbus as the client and read a single known holding register before you request blocks.
  4. Convert the raw word with exactly the byte order, word order, signedness and scale the register map documents, then compare against the local device indication.
  5. When a router or wireless hop enters later, retest latency, loss detection and reconnection; a network change must never change the process scaling.

Checkpoint 4 passes when repeated reads of a steady input return the same raw word at client and server, and the converted engineering value matches the local indication. The worked example below shows the arithmetic and the failure signatures.

Bind SCADA tags and log a timestamped value #

Bind SCADA only after Checks 1 to 4 pass, or every screen fault becomes a guessing game. A documented lab stack for this step is Kepware as the OPC server, Ignition as the SCADA package and SQL Express as the database. The evaluation runtimes described for Kepware and Ignition stop after two hours and restart on demand — confirm current licensing terms with each vendor before you schedule around that.

  1. Create the controller connection in the OPC server and expose only the tags the training project needs.
  2. Build one screen: process value, communication status, command, permissive state, output state, alarm.
  3. Give the data distinct visual states for good, stale or bad quality, active alarm and acknowledged alarm; a failed read must never look like a believable process value.
  4. Trend the scaled value and store it with a timestamp and a quality indication.
  5. Restart each component separately — controller, OPC server, SCADA, database — and watch reconnection, current-value recovery and the absence of unintended commands.

When this stack later moves from a laptop into a cabinet, an industrial mini PC hosts the OPC server, SCADA client and database beside the controller.

Checkpoint 5 passes when the SCADA value equals the PLC engineering value, the alarm follows the PLC alarm condition, and a new database row appears for every logging interval you configured.

Worked example: taking one temperature register from raw word to degrees Celsius #

Inputs, each with its unit and its source:

  • Raw word at the pymodbus client: 247 counts, read from a steady input (illustrative value; yours comes from your own read).
  • Register-map scale: 0.1 °C per count, the kind of entry a register map documents; take yours from the device documentation.
  • Local indication: 24.7 °C on the device display or the PLC engineering value.

Rule in words: the engineering value equals the raw count times the documented scale per count. Byte-order rule: if the two bytes of the 16-bit word arrive reversed, the value reads about 256 times too large.

Arithmetic:

  • Conversion: 247 counts × 0.1 °C/count = 24.7 °C.
  • Byte-order cross-check: 247 × 256 = 63,232. In hex, 247 is 0x00F7; byte-reversed it reads 0xF700 = 63,232.

Result: the client reports 24.7 °C against a local indication of 24.7 °C.

Decision: the two agree at the map's resolution of 0.1 °C, so Checkpoint 4 passes and you may bind SCADA tags. A client value near 63,232 is a byte-order fault, not a scaling fault — fix the byte-order setting and reread before touching any scale factor. A value that wanders between reads on a steady input is a link fault — fix addressing or the serial line before trusting any conversion.

Grow the slice, not the subject list #

With all five checkpoints green, widen one layer at a time, and give each addition its own pass/fail test: a second input type (analog, if you started with a switch), a second protocol such as PROFINET or EtherNet/IP beside the working Modbus link, an OPC UA server in front of the controller instead of polled tags. Vendor academies — CODESYS training, for instance, runs from programming basics upward — fill in language depth while your slice supplies the context. The habit that carries into real projects is the one you just practiced: one signal, every layer, a test at each layer, and no layer trusted until the layers below it pass.

Questions asked

Can I practise PLC programming without buying a PLC?

Yes. The CODESYS simulator runs the same logic as a hardware controller, so you can learn ladder, function block and structured text with no purchase. Two things it cannot give you: terminal-level wiring and the failure behavior of real field circuits. Also note that forcing an input in software bypasses the sensor, conductor, terminal, supply and input electronics. Use a force to isolate logic, then remove it and repeat the test through the real circuit.

Which PLC platform should a beginner learn first?

Learn the one your target employers use when you know it, because interviews test the environment. Otherwise start with CODESYS for the simulator and its IEC 61131-3 languages, then add a Siemens S7-1200 with TIA Portal Basic when you want onboard I/O and real terminals. Before buying any CPU, check its datasheet for the documented onboard digital and analog channel counts, because they differ across the range, so analog work does not force an extra module.

Which SCADA software is best for a beginner's first project?

For a home lab, a documented low-cost stack is Kepware as the OPC server, Ignition as the SCADA package and SQL Express as the database. The evaluation runtimes described for Kepware and Ignition stop after two hours and must be restarted, which is workable for training: save your project, restart the runtime, reconnect. Confirm current licensing terms with each vendor before you build a schedule around that limit.

Do I need an Arduino or Python skills to learn PLC and SCADA?

Not to start, but both earn a place. An Arduino-class board running OpenPLC is an inexpensive ladder-logic trainer, and a Python client built on pymodbus is the clearest way to watch a Modbus transaction, because you write the read and see the raw word come back. That same Python client is what you reuse to test a wireless hop through a router before any commercial SCADA depends on the link.

What is the difference between PLC, SCADA and DAQ work?

A PLC executes deterministic control logic on a scan. An HMI presents one machine or process to an operator. SCADA supervises data, alarms, trends and commands across several controllers. DAQ, data acquisition, is the acquiring, scaling, timestamping and storing of process values, usually on the historian side. The functions overlap in commercial software, but the split matters on a project: the PLC stays the authority for interlocks, while SCADA requests and records.