Body shop framing line
An automotive body shop framing line running at 55 second takt, one body at a time, with per-VIN genealogy: three respot cells, a torque station, a gauge station and end of line. Seven devices and 181 tags.
Operator view | port 4014 |
|---|---|
Protocol servers | port 5024, 5124 |
Devices and tags | 7 devices, 181 tags |
Litmus Edge driver | Modbus TCP and Open Protocol |
Image | automotive-body-shop-demo |
Scenarios
- Fastening containment scoped to the bodies actually affected. When a tightening result goes out of window, the question is which vehicles carry the suspect joint. Per-VIN genealogy answers it in bodies rather than in shifts.
- Cold welds that a stepper hides. A weld controller's own counters report the schedule it ran, not the joint it made. Electrode wear running away produces welds that pass the controller and fail the part.
- The constraint against takt. Every station reports its cycle against the 55 second takt, so the station to fix is the one really costing throughput rather than the one that stopped most recently.
Overview
This is the only solution here that speaks two industrial protocols at once, and that is the point rather than a complication.
- Six stations answer Modbus TCP on 5024, addressed by unit id.
- The tightening tool controller answers Atlas Copco Open Protocol on 5124, where the driver's own field names are the domain model rather than something invented for a demo.
Both ports must be reachable from the Edge. Publishing only the Modbus port leaves the torque station unreachable behind a solution that otherwise looks healthy.
What it creates on Litmus Edge
Seven DeviceHub devices covering the three respot cells, the torque station, the gauge station, end of line and the underbody supply, with 181 tags. A Digital Twin model and instance per station. Analytics groups behind the containment, weld quality and takt figures.
Requirements
- Litmus Edge 4.0.x, reachable over HTTPS from the host running the solution
- An API token for that Edge, or a username and password, or a client id and secret
- Docker, and Docker Compose for the compose deployment
- A network path in both directions: the solution reaches the Edge's API, and the Edge reaches this host on the protocol port
Deploy
The solution ships two ways. Use the registry if the host can reach Google Artifact Registry, and the downloaded archive if it cannot.
Option 1: pull from the registry
Requires a read-only registry credential, supplied by Litmus separately.
cat key.json | docker login -u _json_key --password-stdin https://us-docker.pkg.devSave this as docker-compose.yml:
services:
body-shop:
image: us-docker.pkg.dev/litmus-customer-facing/litmus-solutions/automotive-body-shop-demo:0.6.1
container_name: automotive-body-shop-demo
restart: unless-stopped
ports:
- target: 4014
published: 4014
protocol: tcp
- target: 5024
published: 5024
protocol: tcp
- target: 5124
published: 5124
protocol: tcp
environment:
# Fill these in.
EDGE_URL: "${EDGE_URL:-}"
EDGE_API_TOKEN: "${EDGE_API_TOKEN:-}"
SIM_HOST: "${SIM_HOST:-auto}"
APPLY_ON_START: "${APPLY_ON_START:-1}"
EDGE_VERIFY_TLS: "${EDGE_VERIFY_TLS:-0}"
# Optional: publish the twins into Litmus Unify.
UNIFY_URL: "${UNIFY_URL:-}"
UNIFY_USERNAME: "${UNIFY_USERNAME:-}"
UNIFY_PASSWORD: "${UNIFY_PASSWORD:-}"
UNIFY_CONNECTOR: "${UNIFY_CONNECTOR:-}"
HTTP_PORT: "4014"
MODBUS_PORT: "5024"
OPEN_PROTOCOL_PORT: "5124"
AUTOSTART: "1"
TICK_SECONDS: "0.2"
TIME_SCALE: "5"
SEED: "7"
LOG_LEVEL: "INFO"EDGE_URL=https://10.0.0.5
EDGE_API_TOKEN=your-token
SIM_HOST=10.0.0.9docker compose up -dOr, without Docker Compose, run the same image with the same .env:
docker run -d \
--name automotive-body-shop-demo \
--restart unless-stopped \
-p 4014:4014 \
-p 5024:5024 \
-p 5124:5124 \
--env-file .env \
-e APPLY_ON_START=1 \
-e EDGE_VERIFY_TLS=0 \
-e HTTP_PORT=4014 \
-e MODBUS_PORT=5024 \
-e OPEN_PROTOCOL_PORT=5124 \
-e AUTOSTART=1 \
-e TICK_SECONDS=0.2 \
-e TIME_SCALE=5 \
-e SEED=7 \
-e LOG_LEVEL=INFO \
us-docker.pkg.dev/litmus-customer-facing/litmus-solutions/automotive-body-shop-demo:0.6.1Flags given with -e take precedence over .env, so change APPLY_ON_START or EDGE_VERIFY_TLS on the command line rather than in the file.
Open http://localhost:4014.
The page stays on its waiting panel until the Edge carries this solution's devices. That is deliberate: the simulation does not tick and no value is shown until Litmus Edge is verified to hold the devices and poll them, so nothing on screen can be mistaken for data that never made the trip. With APPLY_ON_START at its default of 1 the solution configures the Edge itself on startup, which takes 30 to 60 seconds. If you set it to 0, or the apply failed, press Apply to Edge in the page header.
Option 2: load the downloaded archive
Download automotive-body-shop-demo-0.6.1-amd64.tar.gz from the solution's page on portal.litmus.io. The archive is the container image, not a source bundle, and needs no registry access.
docker load -i automotive-body-shop-demo-0.6.1-amd64.tar.gzdocker load prints the image it added:
Loaded image: us-docker.pkg.dev/litmus-customer-facing/litmus-solutions/automotive-body-shop-demo:0.6.1That reference is the one the compose file above already names, so the same docker-compose.yml and .env, or the docker run command above, now work offline with no docker login:
docker compose up -dTo run it without Compose, pass the same three values on the command line:
docker run -d \
--name automotive-body-shop-demo \
--restart unless-stopped \
-p 4014:4014 \
-p 5024:5024 \
-p 5124:5124 \
-e EDGE_URL=https://10.0.0.5 \
-e EDGE_API_TOKEN=your-token \
-e SIM_HOST=10.0.0.9 \
us-docker.pkg.dev/litmus-customer-facing/litmus-solutions/automotive-body-shop-demo:0.6.1Configuration
Variable | Default | What it does |
|---|---|---|
EDGE_URL | the Docker host | Litmus Edge to configure |
EDGE_API_TOKEN | unset | token for that Edge. Or a username and password, or a client id and secret |
SIM_HOST | auto | address the Edge polls to reach this solution |
APPLY_ON_START | 1 | configure the Edge on startup |
EDGE_VERIFY_TLS | 0 | 1 checks the Edge's certificate |
UNIFY_URL | unset | optional: Litmus Unify to publish the twins into |
UNIFY_USERNAME | unset | optional: a Unify user |
UNIFY_PASSWORD | unset | optional: that user's password |
UNIFY_CONNECTOR | the Edge's only one | optional: which Litmus UNS connector on the Edge to publish through |
OPEN_PROTOCOL_PORT | 5124 | the tightening tool controller. Must be reachable from the Edge |
TIME_SCALE | 5 | line runs 5x real time, so a shift of production is watchable |
SEED | 7 | makes a run repeatable |
Litmus Unify (optional)
This solution can also publish its 7 Digital Twins into Litmus Unify, one message per asset under litmus/assembly-plant-01/.... It stays off until two things are true: the UNIFY_ values above are set, and the Litmus Edge has a Litmus UNS connector, which the Solutions provisioner can pair in one click. The next apply then publishes the twins, the page header shows how many are arriving, and removing the solution from the Edge removes its branch from Unify as well. Leave the values empty to keep Unify out of it.
Operator view
The six stations across the top with their live tags, cycle time against takt, and job per hour. Below them, bodies moving down the line with their VINs, and the buffers between stations.
Each body carries its own genealogy, so a fault introduced at one station can be followed to the vehicles that passed through it while the fault was present.
Faults include electrode wear running away in cell 2, the spindle drifting out of the torque-angle window, a robot fault that holds the line, a shifted framing fixture, and the underbody supply starving cell 1.
Apply and remove
docker compose downUse Clean up in the Solutions provisioner to remove what it created on the Edge.