Maschinen
Conveyors are the circulatory system of any factory. From simple flat belts to synchronised accumulation lines, mastering conveyor automation means understanding mechanics, drives, sensors, safety, and PLC logic at every level — from first principles to advanced engineer depth.
Run the belt, adjust speed, trigger an E-Stop, inject a jam, and watch the PLC state machine respond in real time. The encoder counter and sensor states are shown live.
Watch how products queue in zones without touching. Click a zone to block it and see the upstream stop wave propagate. Release to let the wave clear downstream.
Every application has an optimal conveyor type. The choice depends on product geometry, weight, fragility, temperature, cleanliness requirements, and the need for accumulation or diverting. Selecting the wrong type is one of the most common and expensive automation mistakes.
The most universal type. A continuous loop of belt runs over a drive pulley and a tail pulley, supported by a bed or slider. Suitable for flat, stable products and bulk materials. The belt surface (rubber, PVC, PU, stainless mesh) determines grip and compatibility with cleanroom, food, or high-temperature environments. Belt speed is typically 0.05–2.5 m/s for industrial automation.
// Belt conveyor — key parameters
// Belt speed: v = (π × D_drive × n_motor × (1 - slip)) / i_gearbox
// D_drive = drive pulley diameter [m]
// n_motor = motor speed [rev/s]
// i = gearbox ratio
// slip = typically 0.01–0.03 (1–3%)
// Example: D=0.15m, n=24r/s, i=20, slip=2%
// v = (π × 0.15 × 24 × 0.98) / 20 ≈ 0.554 m/s
// Throughput: Q = v × product_pitch_spacing [products/s]
// Load: F_drive = μ × (m_belt + m_product) × g
// Power: P = F_drive × v / η_driveMotorised rollers (MDRs) or line-shaft driven rollers carry products on a series of cylindrical rollers. Ideal for rigid-bottomed products (boxes, totes, pallets). Rollers can be individually controlled for zero-pressure accumulation. 24V DC motorised rollers allow zone-by-zone control directly from a PLC output — no VFD required. Roller pitch must be ≤ 1/3 of product length to prevent tip-over.
// MDR Zone control — 24V DC motorised roller
// Each zone = 1 MDR + 2–4 slave rollers driven by O-rings
VAR
zone_sensor : ARRAY[1..8] OF BOOL; // Photo-eye per zone
zone_motor : ARRAY[1..8] OF BOOL; // 24V DC output per zone
zone_fault : ARRAY[1..8] OF BOOL; // MDR fault feedback
END_VAR
// Zero-Pressure Accumulation (ZPA) logic — simplified
FOR i := 1 TO 8 DO
IF zone_sensor[i] THEN
// Zone occupied — check if downstream zone is clear
IF i < 8 AND NOT zone_sensor[i+1] THEN
zone_motor[i] := TRUE; // Run: downstream is free
ELSE
zone_motor[i] := FALSE; // Stop: downstream blocked
END_IF;
ELSE
zone_motor[i] := TRUE; // Zone empty — keep running
END_IF;
END_FOR;Chains (roller chain, flat-top chain) carry heavy, hot, or irregular products that would damage a belt. Slat conveyors use rigid metal or plastic slats mounted on a chain. Common in automotive, foundry, and heavy assembly. Chain pitch and sprocket selection are critical — mismatched pitch causes rapid wear and vibration. Chain elongation must be monitored and compensated.
// Chain elongation monitoring
// New chain: pitch = 25.4 mm (1 inch)
// Worn chain: pitch increases → measure over N links
// Max allowable elongation: typically +2% before replacement
VAR
chain_length_ref : REAL := 2540.0; // 100 links × 25.4 mm
chain_length_now : REAL; // Measured via laser or encoder
elongation_pct : REAL;
chain_worn : BOOL;
END_VAR
elongation_pct := (chain_length_now - chain_length_ref)
/ chain_length_ref * 100.0;
chain_worn := elongation_pct > 2.0; // Trigger maintenance alarmMagnetic conveyors use a belt or chain with embedded magnets to carry ferrous parts vertically or inverted. Overhead conveyors (power-and-free, monorail) carry heavy workpieces on carriers suspended from an elevated track. Power-and-free systems allow carriers to be buffered, switched to branches, and individually dispatched — making them a transport backbone for complex assembly plants.
// Power-and-free carrier tracking
// Each carrier has an RFID tag. Scanners at switches read tags.
TYPE CarrierData :
STRUCT
carrier_id : DWORD;
route_code : INT; // Which assembly path to follow
part_type : STRING[16];
station_log : ARRAY[1..12] OF STRING[8]; // 'OK'/'NOK'/'SKIP'
END_STRUCT
END_TYPE
// At a switch point: read tag, decide branch
IF rfid_scan_ok THEN
carrier := read_rfid(); // Returns CarrierData
IF carrier.route_code = 1 THEN
switch_actuate := BRANCH_A;
ELSIF carrier.route_code = 2 THEN
switch_actuate := BRANCH_B;
END_IF;
END_IF;The drive system converts electrical energy into belt/chain motion. It consists of a motor, optional gearbox, and a control element. In modern automation, Variable Frequency Drives (VFDs) are almost universal — they allow soft-start, speed control, and controlled deceleration, dramatically extending belt and motor life compared to direct-on-line (DOL) starting.
Under-sized motors overheat and trip. Over-sized motors waste energy and cost more. Correct sizing requires: calculating the total resistive force (friction, gravity on inclines, acceleration), multiplying by belt speed to get mechanical power, then dividing by drive efficiency and applying a service factor (typically ×1.5–2.5 for start conditions). Always size for the worst-case loading scenario.
// Motor sizing calculation (ST)
// Conveyor: horizontal, 5m long, 40 kg max product load
// Belt mass ≈ 8 kg, friction coeff μ = 0.05, v = 0.5 m/s
// Acceleration time: 1.0 s from 0 to full speed
VAR
m_product : REAL := 40.0; // kg
m_belt : REAL := 8.0; // kg
mu : REAL := 0.05; // rolling friction
v_belt : REAL := 0.5; // m/s
t_accel : REAL := 1.0; // s
eta : REAL := 0.88; // gearbox+belt efficiency
SF : REAL := 2.0; // service factor
F_friction : REAL;
F_accel : REAL;
F_total : REAL;
P_mech : REAL;
P_motor : REAL; // Required motor power
END_VAR
F_friction := mu * (m_product + m_belt) * 9.81; // = 23.5 N
F_accel := (m_product + m_belt) * v_belt / t_accel; // = 24 N (peak)
F_total := F_friction + F_accel; // = 47.5 N
P_mech := F_total * v_belt; // = 23.75 W
P_motor := P_mech / eta * SF; // ≈ 54 W → use 90W/0.09kWA VFD that is simply plugged in with default settings will not perform well on a conveyor. Critical parameters to configure: Acceleration ramp (P1-120): controls start jerk. Deceleration ramp (P1-121): controls stop positioning accuracy and prevents DC bus overvoltage. Minimum frequency (P1-001): prevents motor from running below safe magnetising frequency. Boost voltage: compensates for resistive voltage drop at low speed ensuring full torque from standstill.
// Typical VFD parameter settings for a belt conveyor
// (Parameter naming varies by manufacturer — shown as generic)
// P_base_freq = 50 Hz (motor nameplate)
// P_base_voltage = 400 V (motor nameplate)
// P_motor_current = 2.1 A (motor nameplate)
// P_accel_time = 3.0 s (ramp 0→50 Hz — smooth belt start)
// P_decel_time = 4.0 s (ramp 50→0 Hz — soft stop)
// P_min_freq = 5 Hz (minimum speed ≈ 0.05 m/s)
// P_max_freq = 60 Hz (allows 20% speed boost if needed)
// P_boost_volt = 4% (extra voltage at low speed for torque)
// P_overload_cur = 150%/60s (trip on sustained overload)
// P_brake_resist = ENABLED (external braking resistor connected)
// Control word via PLC (e.g. PROFIDRIVE / DSP402):
// Bit 0: Enable Bit 1: Quick-stop Bit 3: Enable Op
// Bit 4: Ramp hold Bit 6: Setpoint en. Bit 10: Remote ctrlDirect-On-Line (DOL) starting applies full voltage instantly — start current = 5–8× rated current, causing belt jerk and motor stress. Soft starters ramp the voltage (not frequency), reducing start current to ~2–3× rated, but cannot control speed. VFDs ramp both voltage and frequency, giving full torque at any speed, regenerative braking capability, and full diagnostic feedback. VFDs cost more but are the only choice for speed control or positioning.
// Comparison table — conveyor starting methods
//
// Method Start Current Speed Ctrl Regen Braking Cost
// DOL 5–8 × In No No Low
// Soft Start 1.5–3 × In No No Med
// VFD 1.0–1.5 × In YES YES (+ resist) High
//
// DOL use case: short conveyors, light load, rare starts
// Soft starter: medium conveyors, no speed control needed
// VFD use case: positioning, speed recipes, long conveyors,
// inclined conveyors, frequent start/stopSensors are the eyes of the conveyor. The right sensor in the right position eliminates jams, enables tracking, and triggers operations at the correct moment. Wrong technology = unreliable detection, false triggering, or missed parts.
Photoelectric (through-beam, retro-reflective, diffuse) sensors are the most common for presence detection. Through-beam is most reliable (separate emitter/receiver) but costly to install. Retro-reflective uses a reflector — watch for shiny products creating false reflections. Diffuse (proximity mode) is easiest to install but range and background suppression vary. Inductive sensors detect metal parts reliably in dusty/wet environments. Ultrasonic handles clear/transparent objects. Vision cameras provide shape, position, and barcode data.
// Sensor selection guide (decision logic)
IF product_material = METAL THEN
// Inductive sensor — immune to dirt, oil, vibration
detection_type := INDUCTIVE;
ELSIF product_transparent = TRUE THEN
// Ultrasonic or fork/through-beam with polarised filter
detection_type := ULTRASONIC;
ELSIF conveyor_length > 3.0 THEN
// Through-beam: reliable over long distances
detection_type := THRUBEAM;
ELSE
// Retro-reflective: cost-effective standard choice
detection_type := RETRO_REFL;
END_IF;
// Always specify:
// - Switching frequency (Hz) ≥ v_belt / min_product_gap
// - IP rating ≥ IP65 for wash-down environments
// - Output type: PNP (source) or NPN (sink) per PLC input cardEncoders measure belt speed and product position accurately. An incremental encoder on the tail pulley or drive shaft provides pulses proportional to belt travel. PLC high-speed counter modules count pulses to calculate position. Resolution: pulses_per_mm = encoder_ppr / (π × pulley_diameter). For a 500 PPR encoder on a Ø100 mm pulley: 500 / (π × 100) ≈ 1.59 pulses/mm. This lets the PLC trigger a stop, gate, or spray exactly X mm after a sensor detects a product edge.
// Encoder-based product positioning
VAR
enc_ppr : DINT := 1000; // Pulses per revolution
pulley_diam_mm : REAL := 100.0; // mm
pulse_per_mm : REAL;
enc_count : DINT; // Read from HSC module
trigger_mm : REAL := 350.0; // Stop 350 mm after sensor
trigger_count : DINT;
tracking_active: BOOL;
stop_output : BOOL;
END_VAR
pulse_per_mm := REAL_TO_DINT(enc_ppr) / (3.14159 * pulley_diam_mm);
trigger_count := REAL_TO_DINT(trigger_mm * pulse_per_mm); // = 1114 pulses
// On rising edge of photo-eye:
IF photo_eye AND NOT tracking_active THEN
enc_count := 0; // Zero HSC
tracking_active := TRUE;
END_IF;
// Trigger stop when target count reached
IF tracking_active AND enc_count >= trigger_count THEN
stop_output := TRUE;
tracking_active := FALSE;
END_IF;Raw sensor signals are noisy. A product tumbling on a roller creates multiple false transitions. Vibration causes inductive sensors to chatter. Digital filtering in the PLC (input filter time, typically 1–10 ms) suppresses electrical noise. Logical debounce with a TOF timer confirms the signal must remain active for N ms before being accepted. This prevents ghost triggers while adding minimal latency.
// Sensor debounce — reject transitions shorter than 20 ms
VAR
raw_sensor : BOOL; // Direct hardware input
dbnc_timer : TON;
dbnc_timer_off : TOF;
sensor_clean : BOOL; // Filtered output to use in logic
END_VAR
// Must be TRUE for 20 ms before accepted
dbnc_timer(IN := raw_sensor, PT := T#20ms);
// Must be FALSE for 15 ms before cleared
dbnc_timer_off(IN := NOT raw_sensor, PT := T#15ms);
// Combine: set on confirmed ON, clear on confirmed OFF
IF dbnc_timer.Q THEN
sensor_clean := TRUE;
ELSIF dbnc_timer_off.Q THEN
sensor_clean := FALSE;
END_IF;
// Note: total added latency = 20ms on leading edge, 15ms trailing
// Must be acceptable for the application timing budgetA well-structured conveyor PLC program is modular, safe, and easy to troubleshoot. The key principle: separate the safety layer from the operational logic, and the operational logic from the HMI/reporting layer. Never interleave them.
Each conveyor zone is a state machine. States: OFFLINE → READY → RUNNING → STOPPING → STOPPED → FAULT. Transitions are guarded by safety, mode, and sensor conditions. All outputs are set only in one place (the state machine), never scattered through multiple rungs or IF blocks. This makes the program predictable and debug-friendly.
// Full conveyor zone state machine
VAR
zone_state : INT := 0;
run_timer : TON;
fault_code : INT := 0;
END_VAR
CASE zone_state OF
0: // OFFLINE
motor_run := FALSE;
IF safety_ok AND power_on THEN zone_state := 1; END_IF;
1: // READY — awaiting start command
IF start_cmd AND NOT estop THEN
zone_state := 2;
END_IF;
2: // RUNNING
motor_run := TRUE;
// Jam detection: product hasn't cleared within timeout
run_timer(IN := product_present, PT := T#8s);
IF run_timer.Q THEN
fault_code := 10; // Jam timeout
zone_state := 5;
END_IF;
IF stop_cmd OR estop THEN zone_state := 3; END_IF;
3: // STOPPING — controlled decel via VFD ramp
motor_run := FALSE;
run_timer(IN := TRUE, PT := T#2s); // Wait for coast-down
IF run_timer.Q THEN
run_timer(IN := FALSE);
zone_state := 4;
END_IF;
4: // STOPPED
IF start_cmd AND NOT estop THEN zone_state := 2; END_IF;
IF estop THEN zone_state := 0; END_IF;
5: // FAULT
motor_run := FALSE;
alarm_output := TRUE;
IF fault_reset AND NOT fault_present THEN
fault_code := 0;
alarm_output := FALSE;
zone_state := 1;
END_IF;
END_CASE;Tracking products across multiple zones without individual zone sensors is possible using a shift-register approach. When a product crosses the entry sensor, a bit is written into position [0] of an array. Each PLC scan, if the belt has advanced one product-pitch (measured via encoder), all bits shift by one position. The bit at position [N] tells the PLC whether a product is in zone N. This works at high speeds where individual zone sensors are impractical.
// Shift-register product tracking (10 zones)
VAR
track_reg : ARRAY[0..9] OF BOOL; // TRUE = product in that slot
enc_count : DINT; // From HSC
pitch_pulses : DINT := 1200; // Encoder pulses per product pitch
shift_trigger: BOOL;
shift_prev : BOOL;
END_VAR
// Load product on entry sensor rising edge
IF entry_sensor AND NOT entry_prev THEN
track_reg[0] := TRUE;
END_IF;
entry_prev := entry_sensor;
// Shift when encoder reaches one product pitch
IF enc_count >= pitch_pulses THEN
enc_count := 0;
shift_trigger := TRUE;
END_IF;
// Shift register (one step forward, MSB first)
IF shift_trigger AND NOT shift_prev THEN
FOR i := 9 TO 1 BY -1 DO
track_reg[i] := track_reg[i-1];
END_FOR;
track_reg[0] := FALSE;
END_IF;
shift_prev := shift_trigger;
shift_trigger := FALSE;Jams are the most common conveyor fault. Detection strategy: a product should clear a sensor within T_max = (sensor_gap + product_length) / v_belt. If the sensor is still blocked after T_max, it is a jam. Auto-recovery: reverse the belt for 1–2 seconds to release the jam, then attempt normal restart. Limit auto-recovery attempts to 3 before requiring operator intervention — repeated jam attempts can worsen the situation or signal a mechanical failure.
// Jam detection and limited auto-recovery
VAR
jam_timer : TON;
jam_detected : BOOL;
recovery_cnt : INT := 0;
recovery_tmr : TON;
max_recovery : INT := 3;
hard_fault : BOOL;
T_jam_max : TIME := T#6s; // Expected max clear time
T_reverse : TIME := T#2s; // Belt reverse duration
END_VAR
// Jam detection
jam_timer(IN := zone_sensor, PT := T_jam_max);
jam_detected := jam_timer.Q;
IF jam_detected AND NOT hard_fault THEN
IF recovery_cnt < max_recovery THEN
// Auto-recovery attempt
recovery_tmr(IN := TRUE, PT := T_reverse);
motor_run := FALSE;
motor_rev := TRUE; // Reverse output
IF recovery_tmr.Q THEN
motor_rev := FALSE;
recovery_cnt := recovery_cnt + 1;
jam_timer(IN := FALSE); // Reset jam timer
recovery_tmr(IN := FALSE);
END_IF;
ELSE
hard_fault := TRUE; // Max attempts reached
motor_rev := FALSE;
fault_code := 20; // JAM_MAX_RECOVERY
END_IF;
END_IF;Conveyors kill and maim people every year. The safety design is not optional and is governed by law (Machinery Directive 2006/42/EC in Europe, OSHA 29 CFR 1910.217 in the US). Risk assessment (ISO 12100) must precede any safety design decision.
ISO 13849-1 defines Performance Levels (PLa–PLe) and categories (B, 1, 2, 3, 4) for safety functions. Most conveyor E-stops target PLd (Category 3 or 4): requires dual-channel redundancy, cross-monitoring, and safe state on any single failure. The PFH (Probability of dangerous Failure per Hour) for PLd is ≥ 10⁻⁷ and < 10⁻⁶. Safety relays (Pilz PNOZ, Schmersal, Sick) or safety PLCs (Siemens F-CPU, Beckhoff TwinSAFE) implement this monitoring in hardware.
// Safety function: Emergency Stop — dual-channel monitoring
// Hardware: 2× NC contacts from same E-Stop button
// Wired to 2 independent inputs of safety relay
// The safety relay checks:
// - Both channels are LOW simultaneously (correct)
// - One channel LOW, other HIGH (wiring fault → lock out)
// - Welded contact on reset (unsafe → lock out)
// Safety PLC (TwinSAFE / Siemens Safety F-CPU)
// Safe input block reads both channels
VAR
estop_ch1 : SAFEBOOL; // Safety PLC input 1
estop_ch2 : SAFEBOOL; // Safety PLC input 2
safe_stop : SAFEBOOL; // Output to STO (Safe Torque Off) on VFD
END_VAR
// Dual-channel AND with discrepancy monitoring
safe_stop := estop_ch1 AND estop_ch2;
// Safety kernel monitors discrepancy time < 500 ms
// If channels differ >500ms → safety fault, hold safe_stop FALSEModern VFDs implement STO (IEC 61800-5-2): when STO is activated, the drive stops supplying torque to the motor without removing main power. This is faster and more reliable than a contactor-based power-cut approach. STO achieves SIL2/PLd natively. For higher levels (SIL3/PLe), SS1 (Safe Stop 1: controlled deceleration then STO) or SS2 functions are used. Never bypass STO in the field — it is a certified safety function.
// STO integration: safety PLC output → VFD STO input
// When safety condition met:
// safe_stop signal (SAFEBOOL) → VFD STO terminal (STO_A + STO_B)
// VFD stops PWM output immediately (torque = 0 in <10ms)
// Motor coasts to stop (no active braking in STO)
// For SS1 (Safe Stop 1 — controlled decel then STO):
// safety_plc sends 'decel_cmd' to VFD standard input
// VFD decelerates on configured SS1 ramp (e.g. 2s)
// After ramp complete OR timeout, STO activates
// Monitoring: VFD feeds back STO_status to safety PLC
// STO_status = 1 → STO active, motor safe
// STO_status = 0 → STO not active (motor can run)
// Discrepancy between STO command and status → safety faultPhysical guards with interlocked doors (ISO 14119) prevent access during motion. Door switches must be safety-rated (tongue interlock or coded magnetic). For areas where doors are impractical (maintenance access during slow mode), safety laser scanners (Sick S300, Keyence SZ) define virtual protective fields. When the field is broken, the scanner sends a OSSD (Output Signal Switching Device) signal to the safety PLC — dual-channel, cross-monitored, the same as an E-Stop.
// Safety laser scanner zone management
// Scanner defines 3 zones: WARNING, PROTECTIVE, MUTING
// OSSD1 + OSSD2: dual-channel PNP safety outputs
VAR
scanner_ossd1 : SAFEBOOL; // Channel 1
scanner_ossd2 : SAFEBOOL; // Channel 2
warning_field : BOOL; // Standard output
person_in_zone : SAFEBOOL;
muting_active : BOOL; // Allow product through, not people
END_VAR
// Person in protective field = conveyor stops
person_in_zone := scanner_ossd1 AND scanner_ossd2;
// Muting: sensor pair brackets confirm product (not person)
// Only mute when muting sensors triggered IN CORRECT SEQUENCE
IF muting_sensor_1 THEN
muting_tmr(IN:=TRUE, PT:=T#500ms);
END_IF;
IF muting_sensor_2 AND muting_tmr.Q THEN
muting_active := TRUE; // Product confirmed — bypass scanner
END_IF;At engineer level, conveyor systems integrate with line controllers, MES systems, and other machines via industrial fieldbus networks. Synchronisation of multiple conveyors to maintain gap, pitch, or tension requires closed-loop speed cascades. Understanding these concepts separates a technician from a systems engineer.
When two conveyors run in series (e.g. infeed + main), a dancer arm or tension sensor between them provides closed-loop feedback. If the downstream conveyor is faster than the upstream, the dancer drops → increase upstream speed. If upstream is faster, dancer rises → reduce upstream speed. This is a PID control loop: SP = target dancer position, PV = actual position, CV = speed reference offset sent to VFD.
// Dancer/tension PID speed cascade
VAR
dancer_pos : REAL; // 0–100%, from potentiometer/encoder
dancer_sp : REAL := 50.0; // Target: 50% = neutral
speed_base : REAL := 30.0; // Base speed Hz (VFD frequency ref)
speed_ref : REAL; // Actual reference sent to VFD
pid_out : REAL; // PID output: ±Hz offset
pid : PID_CONTROLLER;
END_VAR
pid(
SP := dancer_sp,
PV := dancer_pos,
Kp := 0.8,
Ki := 0.15,
Kd := 0.02,
CV => pid_out
);
// Limit offset to ±10 Hz (±33% of base speed)
pid_out := LIMIT(-10.0, pid_out, 10.0);
speed_ref := speed_base + pid_out; // Write to VFD analog or fieldbus
speed_ref := LIMIT(5.0, speed_ref, 60.0); // Hard limitsModern conveyor controllers communicate over PROFINET (Siemens-led) or EtherCAT (Beckhoff-led) at ≤1 ms cycle times. Each VFD, safety device, and I/O module is a node on the network. The PLC exchanges process data (speed reference, status word, fault code) with every drive every scan. PROFIDRIVE (IEC 61800-7-203) defines the standard control and status word format, enabling any PROFIDRIVE-compliant drive to work with any PROFIDRIVE-compliant controller without custom code.
// PROFIDRIVE PZD (Process Data) word structure
// Control Word (PLC → VFD, 16-bit):
// Bit 0: ON / coast-stop (1=run, 0=coast)
// Bit 1: No quick-stop (1=normal, 0=quick-stop)
// Bit 2: Enable operation (1=enabled)
// Bit 3: Enable ramp follow (1=follow ramp)
// Bit 4: Ramp output hold (1=hold)
// Bit 5: Ramp input hold (1=hold)
// Bit 6: Setpoint enable (1=use setpoint word)
// Bit 10: Remote/PLC control (1=PLC controls)
// Status Word (VFD → PLC):
// Bit 0: Ready to switch on
// Bit 1: Ready to operate
// Bit 2: Operation enabled (drive running)
// Bit 3: Fault active
// Bit 5: Switched on & locked
// Bit 7: Alarm/warning
// Speed setpoint: 16384 (0x4000) = 100% of P_max_freq
// e.g. 30 Hz of 50 Hz max → setpoint = 30/50 × 16384 = 9830Overall Equipment Effectiveness (OEE) = Availability × Performance × Quality. A conveyor PLC can calculate all three in real time: Availability = (total_time - downtime) / total_time. Performance = actual_throughput / theoretical_max_throughput. Quality = good_parts / total_parts. Logging to a local database or uploading to MES via OPC-UA enables continuous improvement decisions backed by real data rather than assumptions.
// OEE calculation in PLC
VAR
total_time_s : DINT; // Production window [s]
downtime_s : DINT; // Sum of all stop events [s]
parts_total : DINT; // All parts detected
parts_ok : DINT; // Parts passing quality check
v_actual_avg : REAL; // Average measured belt speed
v_design : REAL := 0.5; // Design speed [m/s]
pitch_m : REAL := 0.3; // Product pitch [m]
availability : REAL;
performance : REAL;
quality : REAL;
oee : REAL;
throughput_max : REAL; // Theoretical parts/s
END_VAR
availability := DINT_TO_REAL(total_time_s - downtime_s)
/ DINT_TO_REAL(total_time_s);
throughput_max := v_design / pitch_m; // parts per second
performance := (DINT_TO_REAL(parts_total) / DINT_TO_REAL(total_time_s))
/ throughput_max;
quality := DINT_TO_REAL(parts_ok)
/ DINT_TO_REAL(parts_total);
oee := availability * performance * quality * 100.0; // %Test everything from basic mechanics to advanced drive and safety architecture. Answers are explained after each question.
A flat belt conveyor belt slips on its drive pulley. What is the most likely primary cause?
A conveyor must move 12 kg of product at 0.4 m/s continuously. The drive efficiency is 85 %. Friction coefficient μ = 0.05. What is the approximate minimum motor power required?
In a conveyor PLC program, a PHOTO_EYE sensor detects a part. The belt should stop 250 ms after detection to position the part under a robot. Which timer type is correct?
What is the purpose of an accumulation conveyor zone?
A VFD (Variable Frequency Drive) controlling a conveyor motor faults with "DC Bus Overvoltage". What is the most likely cause?
IEC 62061 / ISO 13849 requires a conveyor emergency stop to achieve PLd / SIL 2. Your single E-Stop button has a single normally-closed contact. What is missing?
A conveyor belt stretches over time. What is the correct maintenance response?
Which encoder type provides absolute position at power-on without requiring a homing cycle?
A conveyor zone uses zero-pressure accumulation (ZPA). Zone N is full and zone N+1 is empty. What happens to zone N-1 (feeding zone N)?
What does "line shaft" mean in the context of roller conveyors?