A configurable industrial automation framework for PLC-controlled machinery, motion systems, and custom manufacturing equipment.
WeaMachine is a runtime-configurable machine control platform built with C++, Qt, and QML. It combines PLC integration, servo motion control, step-based automation, recipe management, and operator-friendly machine configuration into a unified application.
Instead of hardcoding machine behavior inside PLC ladder logic or application source code, machine workflows can be configured directly through the user interface.
- Overview
- Screenshots
- Getting Started
- Core Features
- Runtime PLC Configuration
- Motion Control
- Step-Based Automation Engine
- Recipe Management
- Machine Monitoring
- Manual Mode
- Automatic Mode
- Architecture
- Technology Stack
- Design Goals
- Project Status
- Contributing
- License
WeaMachine was designed to provide a flexible runtime automation layer for industrial machines.
The platform enables machine builders and integrators to configure machine behavior without modifying application code or PLC programs.
Typical use cases include:
- Servo-driven machinery
- Packaging systems
- Blow molding machines
- Pick & place systems
- Conveyor systems
- Assembly equipment
- Custom manufacturing machines
- CMake 3.16+
- C++17 compiler (MSVC, MinGW, or Clang)
- Qt 5.15+ or Qt 6 with: Core, Quick, Qml, QuickControls2, SerialBus, SerialPort
- Python 3.9+ (optional, for Modbus protocol helpers)
cmake -S . -B build -DCMAKE_PREFIX_PATH=<path-to-Qt>
cmake --build buildOn Windows with an installed Qt kit, point CMAKE_PREFIX_PATH at the kit root (for example C:/Qt/6.7.0/msvc2019_64).
Launch the InjectionMolding target from the build directory. QML is currently loaded from the source tree via PROJECT_SOURCE_DIR (convenient for development).
Default operator login is stored in QSettings under OperatorAuth (defaults: admin / changeme). Change these on the target machine; do not commit production credentials.
python -m pip install -r scripts/requirements.txt
python scripts/protocol_map.py
PYTHONPATH=scripts python -m pytest scripts/tests -qConfigure machine inputs and outputs at runtime.
Supported features:
- Dynamic I/O registration
- Input/output aliasing
- Normally Open (NO) logic
- Normally Closed (NC) logic
- Runtime signal inversion
- Input filtering
- Output filtering
- Persistent configuration storage
Each signal can be extended with configurable timing behavior.
Available options:
- On Delay
- Off Delay
- Blink Interval
- Runtime activation control
This allows machine behavior to be modified without changing PLC logic.
PLC addresses are useful for engineers but often difficult for operators.
WeaMachine allows assigning human-readable aliases to every signal.
Example:
X0 -> Emergency Stop
X1 -> Front Door Sensor
X2 -> Product Detector
Y0 -> Main Valve
Y1 -> Alarm Buzzer
Y2 -> Pneumatic Cylinder
The operator interface can display aliases instead of raw PLC addresses.
Integrated servo motion subsystem with support for:
- Servo ON/OFF
- Homing
- Absolute positioning
- Relative positioning
- Jog control
- Speed configuration
- Acceleration control
- Deceleration control
- Torque monitoring
- Position feedback
The system supports multi-axis industrial motion workflows.
The automation engine is based on configurable execution steps.
Each step may contain:
Step Name
Supported logic operators:
AND
OR
XOR
Example:
Emergency Stop = OFF
AND
Safety Door = CLOSED
AND
Product Sensor = ON
X Axis Position
Y Axis Position
Speed
Acceleration
Deceleration
Set Coil
Reset Coil
Activate Output
Deactivate Output
Next Step Delay = 200 ms
The platform supports multiple machine recipes.
Each recipe can contain:
- Step sequences
- Motion parameters
- Servo positions
- Coil configurations
- Timing values
- Machine-specific settings
Operators can switch between machine profiles without modifying application code.
Real-time monitoring interface providing:
- PLC input status
- PLC output status
- Servo speed
- Servo torque
- Position feedback
- Encoder values
- Alarm information
- Runtime machine state
Manual mode is intended for:
- Machine commissioning
- Maintenance
- Diagnostics
- Troubleshooting
- Hardware verification
Capabilities include:
- Manual output control
- Servo jogging
- Homing operations
- Position testing
- Runtime parameter adjustment
Automatic mode executes predefined machine workflows.
Features include:
- Step execution
- Conditional transitions
- Motion synchronization
- Output control
- Delay management
- Recipe execution
┌─────────────────────────┐
│ Qt/QML UI │
└────────────┬────────────┘
│
┌────────────▼────────────┐
│ Automation Engine │
│ Step Sequencer │
└───────┬────────┬────────┘
│ │
▼ ▼
PLC Layer Motion Layer
(Modbus) (Servos)
- C++17
- Qt
- QML
- OpenGL
- Modbus RTU
- Delta PLC Integration
- Delta Servo Integration
- Multi-threaded Architecture
- Runtime Configurability
- Operator-Friendly Configuration
- Minimal PLC Modifications
- Flexible Machine Integration
- Reusable Automation Components
- Industrial Reliability
🚧 Active Development
The project is currently under active development.
Planned improvements include:
- Advanced motion profiles
- Extended condition system
- Configuration import/export
- Additional diagnostics
- Enhanced visualization
- Machine simulation mode
Tracked work lives in GitHub Issues. Historical notes remain in TODO.txt.
See CONTRIBUTING.md for setup, PR expectations, and issue templates.
This project is licensed under the MIT License.
Parsa Pournabi (Wearily)
Industrial Automation & Software Engineering
C++ • Qt/QML • OpenGL • PLC Integration • Motion Control