02
PLC Hardware Components
In Chapter 1 we met the PLC and learned what its four parts are. Now we open it up and look inside. We’ll see how I/O modules talk to sensors and motors, what makes a discrete signal different from an analog one, what kinds of memory the CPU uses, and how operators interact with the whole system through an HMI screen. Four worked examples at the end will let you put the theory into practice.
What you’ll be able to do after this chapter
Your goals for this chapter:
- Tell the difference between discrete and analog I/O signals and pick the right module for a given field device.
- Describe the role of common special I/O modules (high-speed counters, motion, RTD, communication).
- Read a manufacturer’s I/O specification sheet and check whether a module fits your sensor or actuator.
- Explain what’s inside the CPU and how memory is organised (program file, data file, I/O image tables).
- Distinguish RAM, ROM, EPROM, EEPROM, and flash — and know which one stores what.
- Describe what an HMI is and what makes a good operator screen.
- Pick the right modules and estimate memory size for a small real-world project.
Key Concepts & Terms
The I/O Section — How the PLC Talks to the World
Imagine a PLC sitting alone on a shelf. It has a brain (the CPU), it has memory, it has power. But without anything plugged into it, it can’t see anything happening in the factory, and it can’t do anything in the factory. It’s just a box.
The I/O section is what fixes that. It’s the bridge between the PLC’s electronic world (low-voltage DC, 5 V or 24 V) and the factory’s electrical world (240 V AC motors, 24 V DC sensors, 4–20 mA temperature transmitters, and so on).
Figure 2.0 — The I/O Module FamilyEach module type handles one kind of signal. The CPU is the brain, but the I/O modules do all the talking to the outside world.
The I/O section sits between the CPU and the field devices, and it does three jobs:
- Signal conditioning — a 240 V AC signal from a motor contactor is too dangerous to feed directly to a 5 V CPU. The input module steps it down. An analog 4–20 mA signal from a temperature transmitter has to be converted to a digital number the CPU can read.
- Optical isolation — a small electronic component called an optocoupler separates the field side electrically from the CPU side. There’s no copper connection between them — only a beam of light through a tiny LED. This protects the CPU from voltage spikes, ground loops, and electrical noise.
- Indication — every modern I/O module has a small LED for each input or output point. When the LED is lit, you know the signal is active. This is a huge help when troubleshooting in a noisy factory.
Think of I/O modules as translators
The CPU speaks one language: clean low-voltage digital. The factory speaks a hundred different ones — 24 V DC, 240 V AC, 4–20 mA, thermocouple millivolts, encoder pulses. The I/O modules are translators. Each module knows one specific factory language and converts it into the CPU’s language (or vice versa for outputs).
Discrete I/O Modules — On / Off Signals
The simplest kind of signal is one that is either ON or OFF — nothing in between. A pushbutton is pressed or not pressed. A limit switch is tripped or not tripped. A motor is running or stopped. A lamp is lit or dark. We call these discrete signals (some textbooks call them digital signals — same thing).
A discrete input module reads ON/OFF signals from the factory. A typical card has 8, 16, or 32 input points. Each point is a separate channel that handles one field device. Common voltage ratings:
- 24 V DC — the most common in modern industry. Used with proximity sensors, photoelectric sensors, and 24 V pushbuttons.
- 120 V AC and 240 V AC — used in older plants and where the field wiring already runs at AC line voltage.
- 5 V DC (TTL) — used for very fast signals from high-speed encoders and electronic counters.
A discrete output module drives ON/OFF loads — solenoid valves, pilot lamps, motor contactors, alarm bells. Output modules come in three flavours, each with its own personality:
- Relay output — a tiny mechanical relay inside the module. Can switch AC or DC, isolates the load from the PLC, but slow (5–10 ms) and wears out after millions of operations.
- Transistor output (DC) — solid-state, very fast (less than 1 ms), no moving parts. Limited to DC loads only.
- Triac output (AC) — solid-state, fast, AC-only.
Sourcing vs Sinking — A Word of Caution
Beginners often get confused by the terms sourcing and sinking. They describe how the field device is wired with respect to current flow:
- Sourcing input/output — the device provides current (it’s the source). Common in PNP-style sensors.
- Sinking input/output — the device absorbs current (it’s the sink). Common in NPN-style sensors.
If you connect a PNP sensor to a sinking-only input module, nothing will work — and you’ll be hunting the bug for hours. Always check the module’s “polarity” specification before wiring. Many modern modules are bidirectional and accept either type, but never assume.
Analog I/O Modules — Continuous Signals
Not everything in the world is just ON or OFF. The temperature inside a furnace varies continuously from room temperature to 1200 °C. A tank’s water level moves smoothly from 0 to 100 cm. A motor’s speed can be anywhere from zero to maximum RPM. These are analog signals — they take any value within a range.
Figure 2.1 — Discrete vs Analog SignalsDiscrete signals are like a light switch (on/off only). Analog signals are like a dimmer (any value in between).
An analog input module reads continuous signals from sensors and transmitters. It contains an analog-to-digital converter (ADC) that samples the signal hundreds of times per second and converts it to a digital number that the CPU can use. The most common analog signal standards are:
- 4–20 mA current loop — the industry standard for long cable runs (up to 1 km). Robust against electrical noise.
- 0–10 V DC — common for short cable runs in clean electrical environments.
- ±10 V DC — bipolar signals (positive and negative).
- RTD / Thermocouple — direct millivolt signals from temperature sensors.
An analog output module works the opposite way. It contains a digital-to-analog converter (DAC) that takes a digital number from the CPU and produces a smooth analog signal — typically 4–20 mA or 0–10 V — to drive a control valve, a variable-speed drive, or a chart recorder.
Resolution — How “Smooth” is the Conversion?
Analog modules have a specification called resolution, measured in bits. A 12-bit module divides its full range into 4,096 steps; a 16-bit module divides it into 65,536 steps. A 16-bit module reading 0 to 100 °C can detect a change of about 0.0015 °C — far more precise than most sensors actually deliver. For most jobs, 12-bit resolution is plenty.
Special I/O Modules
Beyond plain discrete and analog cards, manufacturers sell a whole family of special I/O modules for jobs the regular cards can’t handle. You’ll meet many of these as you progress, but here are the most common:
- High-speed counter (HSC) modules — count pulses faster than the PLC’s scan cycle (up to 1 MHz). Used with optical encoders to measure position and rotational speed.
- Motion control modules — drive servo motors with precise position, velocity, and acceleration profiles. Essential for CNC machines and robotic arms.
- RTD and thermocouple modules — dedicated to reading temperature sensors directly, with built-in linearisation and cold-junction compensation.
- Weighing modules — read load cells (typically tiny millivolt signals) for batching, dosing, and tank-content measurement.
- Communication modules — talk to other PLCs, HMIs, drives, and SCADA systems over Ethernet/IP, Modbus, PROFIBUS, DeviceNet, and so on.
- Stepper motor modules — generate the precise pulse trains needed to drive stepper motors.
- BASIC / scripting modules — run custom code (BASIC or C) for tasks the ladder language struggles with, such as complex math or string processing.
The general rule: if your application has a special requirement that doesn’t fit “read this voltage” or “drive this load”, there’s probably a special module for it. Open the manufacturer’s catalogue and look — you’ll usually find one.
Reading I/O Specifications
Every I/O module ships with a specification sheet — a few pages of numbers that tell you exactly what the module can and can’t do. Reading this sheet correctly is one of the most important habits an automation engineer can develop. Here are the key items to look for:
| Specification | What it means | Why you should care |
|---|---|---|
| Number of points | How many channels on the card (e.g. 8, 16, 32) | Decides how many devices one module can handle |
| Voltage rating | What voltage the module accepts (24 V DC, 120 V AC, etc.) | Must match the field device’s voltage exactly |
| Voltage range | Acceptable variation (e.g. 22–26 V DC) | Real-world supplies aren’t perfectly stable |
| Input current | How much current the module draws per point | Affects field power supply sizing |
| Response time | How fast the module reacts to a signal change | Critical for fast-moving parts and high-speed counts |
| Isolation voltage | Voltage the optical isolator can withstand | Higher = more protection for the CPU |
| Leakage current | Current that flows even when the output is OFF | Tiny, but can falsely trigger sensitive loads |
| Operating temperature | Range the module works reliably in | Matters for outdoor or hot-process panels |
| Polarity (DC modules) | Sourcing, sinking, or both | Must match your sensor type — easy to get wrong |
A common saying in industry is: “the sensor and the module must speak the same language.” If the sensor is a 24 V DC PNP-type with a 5 ms response, the module must accept 24 V DC, support sourcing inputs, and respond in less than 5 ms. We’ll work an example of this in the worked examples section.
The Central Processing Unit (CPU)
The CPU is the brain of the PLC. We met it briefly in Chapter 1, but now let’s see what’s inside.
The CPU module contains three main parts:
- Microprocessor — a digital chip that does the actual thinking. Modern PLCs use 32-bit or 64-bit processors clocked at hundreds of megahertz — fast enough to scan a 1000-rung program in under a millisecond.
- Memory — storage for the user program, the data, and the operating system. We’ll look at memory in detail in Section 2.7.
- System bus (backplane) — the high-speed channel that lets the CPU talk to the I/O modules and the power supply. Think of it as the spine of the rack.
On the front of a CPU module you’ll typically find:
- Status LEDs — at minimum, RUN (program executing), FAULT (error), and BAT (battery low). Some CPUs add Communication, Force, and I/O Force indicators.
- A mode key or switch — with positions like RUN, PROG, and REM (remote). RUN tells the CPU to execute the user program. PROG stops execution so you can edit. REM lets the programming software switch modes remotely over the network.
- Communication ports — at least one Ethernet port on modern CPUs, often a USB port for direct connection of the programming laptop, and sometimes an RS-232 or RS-485 port for legacy devices.
- A memory card slot — for an SD card or proprietary memory module. The user program can be backed up to this card and restored after a failure — saving hours of recovery time.
Watchdog Timer — The Safety Net
Inside every CPU there’s a small hardware timer called the watchdog. It must be “petted” by the user program every few milliseconds, otherwise it bites — meaning the CPU resets itself and turns off all outputs. The watchdog catches situations where the program gets stuck in an infinite loop or the scan time grows too long. It’s the safety net that prevents a single bug from leaving the machine running uncontrolled.
Memory Design and Types
The PLC’s memory holds three things: the operating system (the firmware that runs the PLC itself), the user program (your ladder logic), and the data (timer values, counter values, I/O image tables, internal bits, math results). The CPU keeps these areas neatly separated.
Figure 2.2 — PLC Memory MapSystem memory holds the firmware that runs the PLC itself. User memory holds your program and data — this is the part that matters when sizing a project.
Memory Types — RAM, ROM, EPROM, EEPROM, Flash
You’ll meet five different physical memory types when working with PLCs. The big distinction is between volatile memory (loses its contents when power is removed) and non-volatile memory (keeps its contents forever).
| Type | Volatile? | Writable? | Typical use in a PLC |
|---|---|---|---|
| RAM (Random Access Memory) | Yes (needs battery) | Yes, fast | Working memory for the running program; data files |
| ROM (Read-Only Memory) | No | No (factory only) | Boot loader, fixed firmware |
| EPROM (Erasable PROM) | No | Yes, but slow + UV needed to erase | Older PLCs — backup of user program |
| EEPROM (Electrically Erasable PROM) | No | Yes, electrically erased | Modern PLCs — stores user program permanently |
| Flash | No | Yes, fast bulk erase | Modern firmware, memory cards, removable backups |
A useful mental picture
Imagine the PLC’s memory is like a desk. RAM is the working surface — fast, but everything gets wiped clean when you leave the room. EEPROM/Flash is the locked filing cabinet — slower to access, but everything stays exactly where you left it, even after a power cut. Modern PLCs keep the master copy of your program in EEPROM/Flash, then load it into RAM at power-up so it can run quickly.
How Memory Size is Measured
PLC memory is usually quoted in kilowords (kW) or kilobytes (kB). One word in older PLCs was 16 bits (2 bytes); modern PLCs use 32-bit words (4 bytes). A small PLC might have 8 kB of user memory; a large one, 32 MB or more. We’ll work an example of memory sizing in the worked examples section.
Programming Terminals
The programming terminal is the device you use to write, download, and monitor the user program. Today it’s almost always a laptop running the manufacturer’s programming software — RSLogix 5000 / Studio 5000 for Allen-Bradley, TIA Portal for Siemens, GX Works for Mitsubishi, and so on.
The laptop connects to the PLC over Ethernet (most common today) or USB. From the laptop you can:
- Edit the ladder logic on screen, with auto-completion, syntax checking, and instruction help.
- Download the program to the PLC’s memory in seconds.
- Monitor the program live — energised contacts and rungs are highlighted in green, so you can see exactly which logic is active right now.
- Force inputs and outputs for testing — but be careful, this is for commissioning only.
- Upload the program from the PLC back to the laptop (a backup) before any change.
- Save and version the program as a file on disk, so you can keep a history of changes.
In the past, before laptops were common, engineers used handheld programmers — small dedicated devices with a keypad and a tiny screen. They still exist for quick on-site adjustments, but for any serious work, a laptop with proper software is faster, clearer, and more reliable.
Data Recording (Data Logging)
Modern industry runs on data. Quality engineers want to know the temperature of every batch. Maintenance wants to spot the bearing that’s about to fail. Compliance wants a record of every alarm for the last six months. So PLCs need to record data, not just react to it.
There are three common ways to log data from a PLC:
- Internal data file — the PLC stores values in its own memory or on a memory card. Simple, but limited by capacity, and you have to retrieve the file later.
- SCADA / historian — a separate computer running historian software (like Wonderware or AVEVA) connects to the PLC over Ethernet and pulls data continuously. The standard for big plants.
- Cloud / IIoT — a relatively new approach where the PLC sends data through a gateway to a cloud service (AWS IoT, Azure IoT, Siemens MindSphere). Operators view dashboards on their phone, and machine-learning algorithms predict failures.
What you choose depends on how much data, how often, and who needs to see it. For a small machine, the internal data file is fine. For a refinery, you’ll want a proper historian. We’ll come back to this in Chapter 14 when we look at SCADA in detail.
Human-Machine Interface (HMI)
A PLC by itself has no screen. It just blinks a few status LEDs. So how does the operator on the factory floor see what’s happening, change a setpoint, or acknowledge an alarm? Through a Human-Machine Interface (HMI) — a colour touchscreen mounted on the control panel.
The HMI is a small computer running a special graphical program. It connects to the PLC over Ethernet and continuously asks the PLC, “What’s the value of N7:0? Is bit B3:0/2 ON?” The HMI then displays the answers as numbers, bars, lights, and trend graphs that the operator can understand at a glance.
A good HMI screen always answers four questions:
- Is the system running, stopped, or in fault? A clear status banner at the top.
- What are the current key values? Tank levels, motor speeds, batch counts — shown big and clear.
- Are there any active alarms? A flashing red banner if yes, with a clear way to acknowledge.
- How can the operator interact? Start/stop buttons, mode selectors, setpoint entry, alarm reset.
The “shipping container” rule
An old industry rule says: “a good HMI screen could be understood by a new operator looking through the window of a passing shipping container.” If the screen is too cluttered, too small, or hides important information behind menus, you’ve designed it wrong. We’ll design an HMI screen for our bottle filling line in Worked Example 4.
Worked Examples
Four Real Hardware Decisions Engineers Make Every Day
Now let’s apply what you’ve learned. We’ll work through four hardware-planning problems — choosing modules for a tank system, sizing memory for a project, checking specs against a sensor, and sketching an HMI screen. These are the sort of questions you’ll see in exams, in job interviews, and on the first day of your first PLC project.
The problem: A small chemical company wants to automate a water-heating tank. They give you the list of field devices below, and ask, “Which I/O modules do we need to buy?”
Field devices:
- Start button (24 V DC)
- Stop button (24 V DC)
- High-level float switch (24 V DC)
- Low-level float switch (24 V DC)
- Emergency stop button (24 V DC)
- Temperature sensor — PT100, with 4–20 mA transmitter
- Pressure sensor — 4–20 mA transmitter
- Heater — 240 V AC, switched by a contactor
- Drain solenoid valve — 24 V DC
- “Running” lamp — 24 V DC
- “Fault” lamp — 24 V DC
- Control valve — needs a 4–20 mA setpoint signal
Step 1 — Classify each device
The first job is always to classify each field device. Is it discrete or analog? Is it an input or an output? What voltage?
Inputs (5 discrete + 2 analog)
- DI 24 V DC: Start, Stop, E-stop, High level, Low level → 5 points
- AI 4–20 mA: Temperature, Pressure → 2 points
Outputs (3 DC + 1 AC + 1 analog)
- DO 24 V DC: Drain valve, Run lamp, Fault lamp → 3 points
- DO 240 V AC: Heater contactor → 1 point
- AO 4–20 mA: Control valve → 1 point
Step 2 — Pick the modules
Now we go to the manufacturer’s catalogue and pick standard modules that cover what we need. The trick is buy slightly more than you need so the system can grow later. A common rule: leave at least 20% of each module type as spare.
Step 3 — Pick the rack and CPU
A 10-slot rack is a comfortable choice — it gives 7 used slots plus 3 spare slots for future expansion. For a small system like this with about 13 I/O points, a nano or small micro PLC is plenty. Allen-Bradley MicroLogix 1400, Siemens S7-1200, or Mitsubishi FX5U would all be reasonable picks.
The problem: Your small project has about 100 ladder rungs, and uses these instructions and data:
- 100 rungs, each averaging 3 instructions per rung (some have 1, some have 5)
- 10 timers (TON or TOF)
- 5 counters (CTU or CTD)
- 50 internal relays (boolean memory bits)
- 20 integer registers for math and storage
- 10 floating-point registers for analog values
You’re choosing between two PLC models: Model A has 8 kB of user memory; Model B has 32 kB. Will Model A fit? Show the calculation.
Step 1 — Estimate program memory
A typical instruction takes about 2 words (4 bytes) in modern PLC memory. With 100 rungs × 3 instructions = 300 instructions:
Step 2 — Estimate data memory
Each timer or counter typically takes 3 words (12 bytes) — preset, accumulated value, and control bits. Each integer register is 1 word (4 bytes). Each float is 2 words (8 bytes). Internal bits are stored 32 to a word.
Step 3 — Add overhead and conclude
The PLC also reserves memory for the I/O image table and operating-system overhead — typically about 1–2 kB.
Model A is the right choice — it has plenty of headroom for the program to grow, but it’s much cheaper than Model B. Going for the bigger PLC “just to be safe” wastes money. Sizing memory properly is a real engineering skill.
The problem: You’ve inherited a project from another engineer. The spec sheet for the discrete input module they ordered is below, and the proximity sensor on the field side is also below. Will they work together? If not, what’s wrong?
Input module specs
- Voltage: 24 V DC nominal (range 22–26 V)
- Polarity: sourcing inputs only
- Response time: 8 ms typical
- Number of points: 16
- Isolation: 1500 V AC
- Operating temp: 0 to +55 °C
Proximity sensor specs
- Type: NPN open-collector (sinking output)
- Supply voltage: 10–30 V DC
- Output current: max 100 mA
- Response time: 3 ms
- Operating temp: −25 to +70 °C
Step 1 — Check each spec one by one
- Voltage: Sensor accepts 10–30 V DC. Module is 24 V DC. ✓ Match.
- Polarity: Sensor is NPN (sinking). Module accepts sourcing inputs only. ✗ MISMATCH!
- Response time: Sensor reacts in 3 ms; module accepts 8 ms. ✓ Match — module is the slower one, but that’s fine for the input side.
- Temperature: Both work in the 0–55 °C range. ✓ Match.
Step 2 — Diagnose and recommend
The polarity mismatch is the killer. An NPN sensor pulls current from the input down to ground; a sourcing input expects current to flow up from a positive source. Wired together, the input will never see a high signal — the sensor will appear permanently OFF, no matter what’s in front of it.
The problem: Remember the bottle filling line from Chapter 1? Now imagine the operator standing in front of it. They need a touchscreen that shows what the system is doing, lets them start and stop it, and warns them about problems. Let’s design the main HMI screen.
From Chapter 1 we listed the inputs and outputs:
- Inputs: Position sensor, Level sensor, Start, Stop
- Outputs: Fill valve, Conveyor motor, Status lamp
An operator standing at the screen needs to know four things at all times: what’s the system doing, how much have we made, are there any alarms, and how do I control it?
Figure 2.3 — Sample HMI ScreenA clean operator interface with status banner, live process view, key production stats, and four large buttons (Start, Stop, Alarms, Settings). Touch-friendly and readable at a glance.
What every region of the screen does
- Status banner (top, full-width). One single colour answers the question “what’s the machine doing?” — green = running, red = fault, yellow = stopped. The current time is on the right so operators have a timestamp for any incident they note down.
- Process view (left panel). A simple cartoon of the actual machine, with parts that change colour or move when their state changes. The valve symbol turns green when the PLC’s Y1 output is ON. The motor circle turns red when Y2 is ON. This visual feedback tells the operator what is happening, not just that something is happening.
- KPI tiles (right panel). The numbers management cares about — total bottles produced today, current rate per minute, cycle time, uptime percentage. Big fonts, monospace numbers so the digits don’t dance around as values change.
- Action buttons (bottom). Four large, clearly-labelled buttons: Start (green), Stop (red), Alarms (yellow), Settings (blue). Each button is at least 80×120 pixels so a finger in a glove can hit it reliably. The Alarms button shows the current count — “Alarms (0)” if all is well, “Alarms (3)” if there are three to acknowledge.
Common Student Mistakes
Things to watch out for in this chapter:
- Confusing discrete with analog. A pushbutton is discrete (pressed / not pressed). A pressure sensor reading 4–20 mA is analog (any value in between). They need different module types — they are not interchangeable.
- Mixing AC and DC on the same output module. Most output modules are either AC or DC, not both. A 240 V AC contactor cannot share a module with a 24 V DC solenoid.
- Ignoring sourcing/sinking polarity. An NPN sensor on a sourcing-only input will silently fail. Always check the polarity spec — it’s the most common cause of “the system doesn’t work” calls.
- Buying the biggest PLC “to be safe”. A bigger PLC isn’t always better — it’s just more expensive. Size memory and I/O for the project, with 20–30% spare for growth, and stop there.
- Forgetting that RAM needs a battery. Older PLCs lose their program if the backup battery dies during a power cut. Always keep the program backed up to EEPROM, Flash, or a memory card.
- Cluttering the HMI screen. An HMI is not a software dashboard. Every element competes for the operator’s attention — fewer, bigger, clearer is always better.
- Confusing “data logging” with “data display”. Showing a value on the HMI is not logging — it has to actually be saved somewhere (memory card, historian, cloud) to count as logged.
Quick Recap
The eight things to remember from Chapter 2:
- The I/O section is the bridge between the CPU and the field, doing signal conditioning, optical isolation, and indication.
- Discrete I/O handles ON/OFF signals (buttons, switches, lamps); analog I/O handles continuous signals (temperature, pressure, level).
- Output modules come in three types: relay (slow, switches AC or DC), transistor (fast, DC only), and triac (fast, AC only).
- I/O specs always include: voltage, points, response time, isolation, polarity, and operating temperature — and they must match the field device.
- The CPU contains a microprocessor, memory, and the system bus, plus a watchdog timer that protects against runaway programs.
- PLC memory is split between system memory (firmware, fixed) and user memory (program + data, what we size for our project).
- Memory types: RAM (volatile, fast), EEPROM/Flash (non-volatile, holds the program forever).
- The HMI is the operator’s window into the system — a good screen is readable across a room, not just up close.
Review & Self-Assessment
Chapter 2 Review Questions
Try answering each question on your own before tapping to reveal the model answer. The last four questions test the worked examples — make sure you can do those calculations.
Q1What three jobs does the I/O section perform?+
Q2Define discrete and analog signals, and give two examples of each.+
Q3Compare relay, transistor, and triac discrete output modules.+
Q4What is the difference between sourcing and sinking inputs?+
Q5What does “resolution” mean for an analog module, and why does it matter?+
Q6List three types of special I/O modules and what they do.+
Q7What does a watchdog timer do inside the CPU?+
Q8Distinguish volatile from non-volatile memory and give an example of each.+
Q9Example 1 — A system has 6 discrete inputs at 24 V DC, 3 analog inputs at 4–20 mA, and 4 discrete outputs at 24 V DC. List the modules you would order.+
Q10Example 2 — A program has 200 rungs averaging 4 instructions each, plus 20 timers, 10 counters, 80 internal bits. Estimate the total memory required.+
Q11Example 3 — A PNP sensor is connected to a sinking-only input module. What will happen, and how do you fix it?+
Q12Example 4 — Name the four regions of a good HMI screen and what each one shows.+
Need help sizing the hardware for your PLC project?
Get one-on-one guidance from Dr Ahsan Rahman — Head of Electrical Engineering, with two decades of teaching and supervising PLC-based industrial automation projects.