mcp-wms-wiki/wiki_old_13-05-2026/architecture/galileo-integration.md

---
title: "GALILEO Integration (TMS ↔ EasyWMS)"
type: architecture
sources:
  - sources/archives/Presentation_GALILEO.md
  - sources/archives/Communication_WMS_GALILEO.md
  - sources/archives/Communication_Easy_Galileo.md
  - sources/archives/Bases_fonctionnement_robotique_EasyWMS.md
  - sources/archives/Documents_utiles.md
related:
  - concepts/stations.md
  - concepts/mechanical-elements.md
  - concepts/task.md
  - concepts/location.md
  - operations/galileo-simulation.md
  - operations/galileo-troubleshooting.md
  - operations/robotics-project-lifecycle.md
  - modules/automation-dashboard.md
last_compiled: "2026-04-17"
---

# GALILEO Integration (TMS ↔ EasyWMS)

## Overview

**GALILEO** is the Mecalux **Transport Management System (TMS)** — the automation layer that physically controls conveyors, stacker cranes (TK / Miniload), shuttles, AGVs, lifts and all other mechanized equipment. EasyWMS holds all the business intelligence (stock, strategies, orders); **GALILEO has no predictive vision** — it requests work from EasyWMS and executes it.

Two parallel automation controllers exist in the Mecalux ecosystem:

- **GALILEO** — classic PLC-driven TMS, deployed on production sites
- **EasyS** — 3D simulation environment that speaks the same protocol as GALILEO; used for development, demos and pre-site validation (see [Galileo Simulation](../operations/galileo-simulation.md))

Both dialogue with EasyWMS through the **EasyWMS Gateway** Windows service — a translator between GALILEO's low-level frame protocol and the EasyWMS API.

Reference documents:
- [Control_Communications_Interface_EN_GB.pdf](https://msscc.mecalux.com/documentation/Automation/master/ES/Documents/GalileoAWS/Control_Communications_Interface_EN_GB.pdf) — all station types, event types, PIE flags
- [EasyWMSGateway_ControlInterface_EN.pdf](https://msscc.mecalux.com/documentation/documentation/master/ES/docs_downloads/services/docs/EasyWMSGateway_ControlInterface_EN.pdf) — frame structure (low-level)
- [Stations index](https://msscc.mecalux.com/documentation/documentation/master/EN/areas/layout/stations/index.md) — station-specific behaviour
- [IdentErrorType](https://msscc.mecalux.com/documentation/Development/master/ES/apis/easywms/Domain/IdentErrorType.md) — rejection reason codes

## EasyWMS Gateway Service

Windows service that runs on the WMS server and brokers all communication with GALILEO / EasyS.

- **Download**: https://msscc.mecalux.com/documentation/documentation/master/EN/docs_downloads/services/gateway.md
- **Install path**: `C:\Program Files\Mecalux\EasyWMS Gateway 2015`
- **Config file**: `C:\ProgramData\Mecalux\EasyWMS Gateway 2015\Config\MainObject.config`
- **Log file**: `C:\ProgramData\Mecalux\EasyWMS Gateway 2015\Logs\AllLog.log`
- **Service name**: `EasyWMSGateway2015`
- **Port used by GALILEO/EasyS**: TCP 3000 (must be open inbound/outbound on the WMS host)

Config keys (MainObject.config):
- `tenantCode` = tenant of the target WMS
- `TokenUser` = authentication (prefer over `ClientUser`)
- Passwords must be encoded via `PasswordEncrypt.exe` in the install folder

Installation and bring-up procedure: see [Galileo Simulation & Test Setup](../operations/galileo-simulation.md).

## Tasks vs Movements

EasyWMS expresses transport work at two granularities:

- **Task** = end-to-end transfer order for a container (e.g. `PIE → Miniload Location A-12-3`)
- **Movement** = single conveyor-to-conveyor hop inside a task; a single task typically spawns **N movements** (a `PIE → Miniload` task commonly resolves to 4 movements)

A movement can only be generated if a **route** exists in EasyS between its origin station and the next station. If no path exists, EasyWMS generates a **reject task** toward the configured reject station.

### Task lifecycle (robotics view)

| Status | Description |
|--------|-------------|
| **En attente** / Pending | Not yet transmitted to GALILEO, no tracking |
| **Générée** / Generated | Next movement generated but not yet transmitted |
| **En cours** / In progress | Tracking picked up by GALILEO; container placed on virtual location **Mov** |
| **Terminée** / Completed | Container reached the final task destination |
| **Annulée** / Cancelled | Cancelled before reaching destination |

**Mov** is the virtual system location used to hold a container while it's physically travelling between stations. See [Location](../concepts/location.md) and [Task](../concepts/task.md).

## Stations & Routes (from GALILEO's perspective)

Stations are the start/end points of every movement. A station is uniquely identified by the couple **(StationType, StationNumber)** — this pair must be identical in EasyS and in GALILEO; any drift causes `EndErrorCode=4` errors (see Troubleshooting).

For the full reference of station codes (FR/ES/EN), acronyms (ALM/TK/PK/PIE/PS/ME/MS/PKE/CME/ET/MU/REAC/RECH/…) and roles, see [Mechanical Elements](../concepts/mechanical-elements.md) and [Stations & Routes](../concepts/stations.md).

### Route types (EasyS)

| Type | Description |
|------|-------------|
| **Galileo** | Movement that requires calls to the Gateway (physical conveyor moves) |
| **Manual** | Movement that requires an operator action in response to a WMS task |
| **Virtual** | Automatic, instantaneous virtual stock movement (e.g. output → consolidation zone) |

### Routes that MUST report "full" to EasyWMS

GALILEO must be able to report these routes as **full** (status `3`) so the WMS can recirculate / pause:

| Source type | Destination type |
|-------------|------------------|
| CME | TE (or ME) |
| PKE | PK |
| ET | PS |

Sometimes `ETPSxx → PSxx` must be reported to sequence shipping.

### Route status values

| Value | Meaning |
|-------|---------|
| `0` | No communication |
| `1` | Available / in service |
| `2` | Electromechanical fault |
| `3` | Full (and in service) |

## Three Communication Types (initiated by GALILEO)

**All communication is GALILEO → Gateway → EasyWMS.** The WMS never pushes unsolicited commands; it only responds. Three message types drive the workflow plus two status update streams.

### 1. Event (log → `Event`)

Declaration of container presence at a meaningful point. Primary sources:

- **PIE**: reports a new container with label read + gauge data — EasyWMS decides conformity
- **TK**: announces presence
- **Picking confirmation**: operator has finished a picking task

**PIE event fields:**

| Field | Description |
|-------|-------------|
| Code | Container barcode read |
| Weight | Weighed value |
| Dimensions | Physical measurements |
| Container type | PLC Container Type code (starts at 1, defined in PLC Types menu) |
| Height type | PLC Height Type code (starts at 1) |
| Flags | Bitwise gauge check result |
| Event type | Event-specific code (e.g. `9` = reject) |

PIE flag values (bitwise):

| Flag | Meaning |
|------|---------|
| `65536` | Container OK — no error |
| `256` | Barcode error |
| `512` | Recovered container |
| `1024` / `66560` | Correct + empty |
| `3` | Holes + studs detected |
| `4` | Overheight |
| `8` – `64` | Overhangs |
| `128` | Weight excess |

**Two PIE processes depending on container origin:**

1. **New container** — GALILEO reads the label and sends type/height; EasyWMS verifies conformity and decides destination
2. **Known container returning** — EasyWMS pre-sends a movement toward PIE; GALILEO verifies types match, without re-reading the label

**PIE insert modes (set from EasyWMS → Control → Stations):**

- **Normal (known containers)** — reject anything the ASN doesn't recognize
- **Empty container creation** — create supports from the data GALILEO sends (code, weight, height type…)
- **Pallet pile creation** — operator activates "insert pallet piles" on the GALILEO console; GALILEO sends events with `Transport Number = 10`; item code + qty per pile must be defined in EasyWMS

**Workflow triggered:** `Galileo_PIEEventHandler_PR`

To enable instance tracking on PIE events: activate the process `<NomPIE>_<NomEntrepot>_GalileoPIE` in ApplicationService.

### 2. Search (log → `Search`)

GALILEO asks EasyWMS "what should I do with this container?" or "give me a next task". Triggered when:

1. A container arrives at a station and GALILEO needs the next hop
2. A TK/Miniload is idle and polls in a loop (hundreds per second)

**Search content:** tracking number, container code, station (type + number).

**Search response content:** destination station info. Capacity semantics differ by station type:

- **Conveyors / TK**: capacity = number of simultaneous trackings the station can manage
- **PK and PS**: capacity = max containers on the station **plus** all containers in movement toward it

**Station capacity vs route capacity vs WMS logical capacity** (worked example):

| Layer | Typical value for a PK |
|-------|------------------------|
| Physical station PK | 1 container on the conveyor |
| Route to PK | 4 containers in transit on intermediate conveyors |
| WMS PK capacity | 15 — physical + transit + every task whose destination is PK |

**Response state codes:**

| Code | Meaning | Used by |
|------|---------|---------|
| `83` | **S** = Servicio (in service) | Conveyors |
| `70` | **F** = Fallo (fault) | TK |
| `69` | **E** = Error | TK |

**X actual / Y actual** — only meaningful for TK; the current crane position is sent so EasyWMS can optimise task ordering.

**Workflow triggered:** `Galileo_SearchCreatedEventHandler_PR`. Routed by station type inside the process.

**Command used to transmit the order to GALILEO:** `GalileoMovTrackingCreateCommand` (preferred over `GalileoMovTrackingCreateChangingTargetCommand`). Effects:

- Gateway translates the command into a GALILEO frame
- Movement transitions from **Generated** → **In progress**
- Container is virtually relocated to **Mov**

> ⚠️ GALILEO can emit dozens of Search per second per station. **Do not enable workflow instance tracking on Search events carelessly** — scope it to the process and keep trace TTL very short, otherwise the trace tables explode.

### 3. End (log → `End0`, `End1`, …)

Signals that GALILEO has finished the current movement. EasyWMS advances to the next movement of the task (or closes the task).

**End error codes:**

| Code | Meaning | Consequence |
|------|---------|-------------|
| `0` | Movement completed | Next movement generated |
| `1` | Deposit error | Error mask + relocation / reject |
| `2` | Extraction error | Error mask + relocation / reject |
| `4` | Inconsistent order | WMS/GALILEO configuration mismatch — see troubleshooting |
| `7` | Gauge error | Relocation / reject |

**Workflow triggered:** `Galileo_EndCreatedEventHandler_PR`

## Station and Route Status Updates

Sent **every 1–3 seconds** by GALILEO (or immediately on change of state / load).

### Station update (log → `Update station`)

| Field | Meaning |
|-------|---------|
| StationType | Station type code |
| StationNumber | Station number |
| Status | `0` = unavailable (fault, manual mode, safety); `1` = available |
| Loaded | `0` = occupied; `1` = free — **note the inversion** |
| Capacity | Max containers |
| CurrentCount | Current GALILEO trackings on the station |
| Aisle | Aisle number associated with the station |

> ⚠️ The Loaded semantic is inverted between sources: historical GALILEO docs use `1 = free` / `0 = loaded`, while Comprendre_logs_Gateway lists the same values (`1` = libre, `0` = chargé). Always cross-check the log with the current Gateway protocol version.

**Function exposed by GALILEO:**
```
SetStationStatus(Type, Numéro, Status, Présence, Capacité, Occupation, Allée)
```

### Route update (log → `Update route`)

| Field | Meaning |
|-------|---------|
| StationTypeSource / StationNumberSource | Origin station |
| StationTypeDestination / StationNumberDestination | Destination station |
| Status | `0`/`1`/`2`/`3` — see Route status values above |
| CurrentCount | Trackings currently between the two stations |

**Function exposed by GALILEO:**
```
SetRouteStatus(TypeOrigine, NuméroOrigine, TypeDestination, NuméroDestination, Etat)
```

## End-to-End Example — Container Arriving at PIE

```
1. PIE reads label + gauges            → Event (Galileo_PIEEventHandler_PR)
                                         then Search (Galileo_SearchCreatedEventHandler_PR)
2. EasyWMS sends next movement         → container placed on Mov virtual location
                                         movement status → In progress
3. Container reaches next station      → End (Galileo_EndCreatedEventHandler_PR)
4. If on a conveyor                    → new Search
   If on a TK inbound table (TE)       → TK polls Search in loop
5. If shipping conveyor (PS)           → container leaves the installation
   If picking conveyor (PK)            → operator confirms pick → Event → Search
```

## Sequential Machine Model (Grafcet)

Every automation element is a sequential machine (grafcet) with discrete steps and transitions. Typical conveyor sequence:

1. Rest — ready to receive
2. Request output from upstream conveyor
3. Verify conditions (no presence, no tracking…)
4. Copy tracking + physical transfer + (if station) notify WMS
5. Release upstream conveyor
6. Request output toward downstream conveyor
7. Return to rest

This model is visible from the GALILEO SCADA: double-click a machine → **Graph** tab shows the current grafcet step; **Variables** shows live PLC memory.

## Application Dictionary Entry Points

Core workflows:

| Workflow | Trigger | Purpose |
|----------|---------|---------|
| `Galileo_PIEEventHandler_PR` | PIE event | Inbound identification + decision |
| `Galileo_SearchCreatedEventHandler_PR` | Search request | Next-hop routing and task delivery |
| `Galileo_EndCreatedEventHandler_PR` | End notification | Advance movement, handle error codes |

Core commands:

- `GalileoMovTrackingCreateCommand` — push an order frame to GALILEO (preferred)
- `GalileoMovTrackingCreateChangingTargetCommand` — variant that changes target mid-transport (avoid unless strictly necessary)

See [Application Dictionary](application-dictionary.md) for naming conventions and extension points.

## SCADA & Tracking

The GALILEO SCADA (visualization tool) displays machines, trackings and faults in real time.

- **Default credentials**: `mecalux / robmec`
- **Tracking editor** (double-click a machine):
  - *Show tracking* — the order in execution
  - *End order* — force-tell EasyWMS that the pallet has reached destination (manual override)
  - *Machine state* — what GALILEO is currently reporting to EasyWMS
- **Advanced tab (unlock icon + password):**
  - *Variables* — live variables; booleans can be forced
  - *Graph* — current grafcet step
- **Edit buttons:**
  - *Edit tracking* — origin, destination, height, type… (click "Edit" first)
  - *Delete tracking* — remove tracking from the machine
  - *Reset* — jump the grafcet to a specific step

Manual tracking edits are a last-resort diagnostic / recovery tool.

## Related

- [Mechanical Elements (acronyms, conveyors, station codes)](../concepts/mechanical-elements.md)
- [Stations & Routes](../concepts/stations.md) — full station catalogue from the WMS side
- [Galileo Simulation & Test Setup](../operations/galileo-simulation.md)
- [Galileo Troubleshooting (Logs, Faults)](../operations/galileo-troubleshooting.md)
- [Robotics Project Lifecycle](../operations/robotics-project-lifecycle.md)
- [Automation Dashboard](../modules/automation-dashboard.md) — fault monitoring UI
- [Task](../concepts/task.md) · [Location](../concepts/location.md)