Conveyor Load Monitoring & Auto-Speed Regulation — Control Design
Shared by TSIMEREZIVO Team · 4 Oct 2026 · 45 views
# Mining Template: Conveyor Load Monitoring & Auto-Speed Regulation
## 1. Overview
**Purpose:**
A long-haul conveyor belt (crusher discharge → mill feed or stockpile) can fail if overloaded. This template monitors belt load (via motor current draw) and automatically modulates the belt speed downward if approaching maximum safe load, then ramps speed back up once the load decreases. This prevents motor stall, belt slippage, and mechanical damage while maximizing throughput.
**Industry Standards:**
- ISO 5048 (Conveyor Belts—Safety Requirements)
- ASME B29.1 (Safety Rules for Electrical Motor-Driven Conveyor Belts)
- ISO 1346 (Belt Conveyors—Nomenclature)
- DIN 22101 (Conveyor Belts—Calculation of Power Requirements)
**Critical Constraints:**
- **Motor current limit:** typical 80–90% rated current before overload trip
- **Load sensing:** motor current is proportional to belt tension (load); current = base current + load current
- **Acceleration ramp:** belt cannot jump from 30 Hz to 60 Hz; typical ramp time = 30–60 seconds
- **Inertia:** large conveyor belts have high rotational inertia; sudden speed change = mechanical shock, spillage, jams
- **Spillage risk:** if belt speed too low, material piles up and spills off edge; need minimum speed (e.g., 30% of rated)
- **Life prediction:** belt life inversely proportional to speed (faster = shorter life); overspeeding wears belt faster
**Relevant Physics:**
- **Conveyor motor torque:** $\tau = \frac{P}{2\pi n}$ where P = power (W), n = speed (rev/min)
- **Motor current:** $I = \frac{P \times \text{PF}}{V \times \eta}$ (power factor, voltage, efficiency); load current $\Delta I \propto$ conveyor tension
- **Belt tension:** $T = \frac{P}{v}$ where v = belt speed (m/sec)
- **Critical speed for spillage:** material stays on belt if $v > \sqrt{g \times r}$ (g = 9.81 m/s²)
---
## 2. Control Philosophy
```
LAYER 1: Load Sensing via Motor Current
Current low → light load → speed up (maximize throughput)
Current high → heavy load → speed down (protect motor)
Threshold: 85% of rated motor current = warning
Trip threshold: 95% of rated = emergency shutdown
LAYER 2: Adaptive Speed Setpoint
If current > 85% limit:
Reduce speed by 5% every scan (smooth ramp down)
If current < 60% limit:
Increase speed by 2% every scan (gradual ramp up to rated)
Never exceed 100% (60 Hz nominal)
Never drop below 30% (spillage risk)
LAYER 3: Speed Ramp Control (VFD)
Acceleration time: 45 sec (0–60 Hz)
Deceleration time: 60 sec (60–0 Hz)
Limits prevent mechanical shock & belt slip
LAYER 4: Jam Detection
If speed setpoint > 50% but actual speed = 0 for >10 sec → jam
Action: reverse motor 3 seconds, then stop; alert maintenance
LAYER 5: Vibration & Temperature Monitoring
If vibration > threshold (bearing wear), reduce speed
If motor bearing temp > 80°C, activate cooler fan
```
---
## 3. Control Logic (Condensed)
```pascal
{ === CONVEYOR LOAD & AUTO-SPEED REGULATION === }
PROCEDURE Conveyor_Load_Speed_Control
CONSTANTS
RATED_MOTOR_CURRENT_A = 200 { nameplate }
CURRENT_WARNING_PCT = 85 { 170 A on 200 A motor }
CURRENT_TRIP_PCT = 95 { 190 A = hard shutdown }
MIN_SAFE_SPEED_PCT = 30 { prevent spillage }
MAX_SPEED_PCT = 100 { 60 Hz nominal }
SPEED_RAMP_UP_PCT_PER_SCAN = 2 { smooth acceleration }
SPEED_RAMP_DOWN_PCT_PER_SCAN = 5 { load protection }
ACCEL_TIME_SEC = 45 { 0–100% time }
DECEL_TIME_SEC = 60 { 100–0% time }
JAM_TIMEOUT_SEC = 10 { detect stall }
BEARING_TEMP_ALARM_C = 80 { activate cooler }
VARIABLES
motor_current_a : REAL { motor drive feedback }
motor_current_pct : REAL { % of rated }
motor_speed_actual_hz : REAL { VFD feedback }
motor_speed_set_hz : REAL { VFD command }
belt_load_kg : REAL { estimated from current }
belt_load_pct : REAL { % of nominal capacity }
speed_setpoint_pct : REAL { target speed 0–100% }
speed_setpoint_prev_pct : REAL
speed_error_pct : REAL { setpoint vs. actual }
motor_bearing_temp_c : REAL
vibration_level_mm_sec : REAL { RMS acceleration }
jam_detection_counter : INTEGER { seconds without speed }
jam_detected : BOOLEAN
load_status : ENUMERATION { NORMAL | HEAVY | CRITICAL | JAM }
BEGIN
{ === READ SENSORS === }
motor_current_a = Read_Motor_Current_Transducer()
motor_speed_actual_hz = Read_Motor_Speed_Feedback() { VFD encoder }
motor_bearing_temp_c = Read_Bearing_Thermostat()
vibration_level_mm_sec = Read_Vibration_Sensor() { accelerometer }
{ === LOAD ESTIMATION === }
{ Current = base load (belt friction) + material load }
base_current_a = 40 { no load current }
load_current_a = motor_current_a − base_current_a
belt_load_kg = load_current_a × 2.5 { calibration factor }
motor_current_pct = (motor_current_a / RATED_MOTOR_CURRENT_A) × 100
belt_load_pct = belt_load_kg / 2000 × 100 { typical max 2000 kg }
{ === ADAPTIVE SPEED CONTROL === }
speed_error_pct = 0 { initialize }
{ Load-based speed adjustment }
IF motor_current_pct > CURRENT_WARNING_PCT THEN
{ Heavy load: reduce speed to unload belt }
speed_setpoint_pct = speed_setpoint_pct − SPEED_RAMP_DOWN_PCT_PER_SCAN
load_status = HEAVY
Log_Warning("HEAVY_LOAD", current_pct=motor_current_pct, speed_reducing=true)
ELSIF motor_current_pct < 60 THEN
{ Light load: gradually increase speed toward max }
IF speed_setpoint_pct < MAX_SPEED_PCT THEN
speed_setpoint_pct = speed_setpoint_pct + SPEED_RAMP_UP_PCT_PER_SCAN
END IF
load_status = NORMAL
END IF
{ Enforce limits }
IF speed_setpoint_pct < MIN_SAFE_SPEED_PCT THEN
speed_setpoint_pct = MIN_SAFE_SPEED_PCT
END IF
IF speed_setpoint_pct > MAX_SPEED_PCT THEN
speed_setpoint_pct = MAX_SPEED_PCT
END IF
{ === EMERGENCY SHUTDOWN === }
IF motor_current_pct > CURRENT_TRIP_PCT THEN
load_status = CRITICAL
Log_Alarm("MOTOR_OVERCURRENT_TRIP", current_pct=motor_current_pct)
speed_setpoint_pct = 0
motor_speed_set_hz = 0
{ Relay shutdown to local starter }
Command_Motor_Stop()
END IF
{ === JAM DETECTION === }
{ If command is given but belt doesn't move, jam is likely }
IF speed_setpoint_pct > 50 AND motor_speed_actual_hz < 5 THEN
jam_detection_counter = jam_detection_counter + scan_time_sec
IF jam_detection_counter > JAM_TIMEOUT_SEC THEN
jam_detected = TRUE
load_status = JAM
Log_Alarm("CONVEYOR_JAM_DETECTED")
{ Attempt reverse to dislodge }
motor_speed_set_hz = −20 { reverse at 20 Hz }
WAIT 3000_ms { hold 3 sec }
motor_speed_set_hz = 0 { stop }
jam_detection_counter = 0
END IF
ELSE
jam_detection_counter = 0
END IF
{ === VIBRATION & TEMPERATURE MONITORING === }
IF motor_bearing_temp_c > BEARING_TEMP_ALARM_C THEN
Log_Warning("MOTOR_BEARING_TEMP_HIGH", temp_c=motor_bearing_temp_c)
{ Activate cooler fan or reduce speed }
Command_Cooler_Fan(ON)
speed_setpoint_pct = speed_setpoint_pct × 0.9 { reduce to 90% }
END IF
IF vibration_level_mm_sec > 8.0 THEN
Log_Warning("HIGH_VIBRATION_BEARING_WEAR", vibration=vibration_level_mm_sec)
{ High vibration suggests bearing wear or misalignment }
speed_setpoint_pct = speed_setpoint_pct × 0.85 { reduce to 85% }
END IF
{ === VFD COMMAND WITH RAMP TIME === }
{ Convert % to Hz (0–60 Hz range) }
motor_speed_set_hz = speed_setpoint_pct / 100 × 60
{ Send to VFD with acceleration/deceleration time parameters }
Command_VFD({
frequency_hz: motor_speed_set_hz,
accel_time_sec: ACCEL_TIME_SEC,
decel_time_sec: DECEL_TIME_SEC
})
{ === DATA LOGGING (every 5 minutes) === }
IF MOD(scan_count, 300) = 0 THEN
Log_Process_Data({
timestamp: Get_Timestamp(),
motor_current_a: motor_current_a,
motor_current_pct: motor_current_pct,
belt_load_kg: belt_load_kg,
speed_actual_hz: motor_speed_actual_hz,
speed_setpoint_hz: motor_speed_set_hz,
load_status: load_status,
bearing_temp_c: motor_bearing_temp_c,
vibration_mm_sec: vibration_level_mm_sec
})
END IF
speed_setpoint_prev_pct = speed_setpoint_pct
END PROCEDURE
```
---
## 4. Tag List
```
MOTOR_CURRENT_A { actual motor current draw }
MOTOR_CURRENT_PCT { percentage of rated }
BELT_LOAD_KG { estimated material weight }
BELT_LOAD_PCT { percentage of max capacity }
MOTOR_SPEED_ACTUAL_HZ { VFD feedback }
MOTOR_SPEED_SETPOINT_HZ { VFD command }
MOTOR_SPEED_SETPOINT_PCT { 0–100% }
MOTOR_BEARING_TEMP_C { thermal protection }
VIBRATION_LEVEL_MM_SEC { bearing health }
LOAD_STATUS { NORMAL|HEAVY|CRITICAL|JAM }
JAM_DETECTED { boolean alarm }
COOLER_FAN_ENABLED { temperature mitigation }
```
---
## 5. Alarm & Trip Matrix
| **Condition** | **Severity** | **Action** |
|---|---|---|
| **Current > 85%** | ⚠ WARN | Begin speed reduction, unload |
| **Current > 95%** | 🔴 CRIT | Emergency stop (trip motor) |
| **Jam detected (10 sec stall)** | 🔴 CRIT | Reverse 3 sec, then stop |
| **Bearing temp > 80°C** | ⚠ WARN | Reduce speed, enable cooler fan |
| **Vibration > 8 mm/s** | ⚠ WARN | High vibration; reduce speed |
---
**Document Version:** 1.0
**Last Updated:** 2026-04-13
**Status:** Ready for Production