Vision project start stop handshake troubleshooting

A vision-guided cell can accept a stop command while ignoring start because the commands act on different parts of the project lifecycle. Stopping an active project does not necessarily leave it loaded, initialized, selected and ready for another start. This troubleshooting procedure helps you separate those states, trace the command through the controller and define a PLC handshake that reports progress instead of relying on an unverified pulse.

Separate project state from machine state

Begin with the controller's documented project-handling interface. Determine whether its start command starts an execution task, resumes a selected project, or invokes a project manager that must already be running. Do not assume that similarly named inputs perform the same preparation.

A useful diagnostic sequence is:

No project → Loading → Loaded → Initializing → Ready → Starting → Running

Treat this as a proposed application model, not a universal controller state diagram. Some systems combine states or expose different names. Map each state to documented status information before implementing the handshake.

A stop command might end processing without unloading the project. It might also terminate a task needed to receive subsequent commands. Record what actually remains active after stopping.

Project readiness is also different from machine permission to operate. Keep process readiness, motion permission and safety status distinct.

If the failure occurs only after a controller restart, also follow the checks in conveyor vision startup synchronization troubleshooting. The question here is narrower: which project-lifecycle transition has failed?

Check likely causes in order

Use a timestamped trace rather than changing several settings together. Capture the PLC command, controller input, selected project, execution state, readiness, acknowledgement and fault indication.

For context-dependent failures, vision picking project changeover ownership faults provides a separate ownership check. A valid electrical input cannot start the intended project if its command belongs to another context.

Prove loading and initialization before testing start

Test each transition independently, using the documented interface and a controlled cell state.

1. Confirm the destination. Record the selected project identity and the controller receiving the request. Verify that the application targets that same project.
2. Load the required project-handling components. Some systems require a manager or execution module before project commands become effective. Follow the manufacturer's documented loading procedure; do not infer a module name from another installation.
3. Request project loading. Observe completion through an explicit loaded status or documented equivalent. A successful command write is not proof that loading finished.
4. Run initialization where required. Check configuration, required device connections and execution prerequisites. Record the first reported fault rather than repeatedly retrying.
5. Wait for readiness. Require the documented ready indication and absence of blocking faults. Keep machine operating permissions separate from project readiness.
6. Issue a fresh start request. Observe command acceptance and then running status. These are separate observations, even when they occur close together.

If loading fails, inspect project destination and controller association before editing I/O logic. The article on vision project controller mapping addresses that branch.

After each failure, preserve the trace. Repeated starts can obscure the original fault or create queued requests in an interface that supports them.

Verify edge handling at the receiving interface

Check whether start is rising-edge triggered, level-sensitive or part of a request-and-acknowledgement exchange. The PLC output alone cannot establish which behavior the receiver implements.

For an edge-triggered command, the receiver must observe both the inactive state and the subsequent active state. A request left active through stopping may provide no new start edge.

Sampling also matters. For example, a 10 ms pulse can fall entirely between input observations spaced 20 ms apart. Input filtering, communications updates and task scheduling can add further uncertainty. These are illustrative timing values, not settings for a particular controller.

Trace the receiving logical input, not just the PLC output image. If the pulse reaches that input but produces no acknowledgement, move upstream into project state and command interpretation.

Do not stretch a pulse indefinitely as a substitute for understanding the interface. A level-sensitive command could then behave differently after a fault reset or readiness change.

Define a PLC handshake with observable outcomes

Agree on a signal contract before writing the sequence. The following names are illustrative application signals, not existing controller features.

For a custom maintained-request interface, define the complete exchange: request asserted, acknowledgement asserted, request cleared, acknowledgement cleared. Do not impose that exchange on a built-in interface with different semantics.

Acknowledge acceptance separately from completion. Acceptance means the receiver recognized the request; running means the requested transition succeeded.

Define what happens if ordinary start and stop arrive together. Where your application owns the arbitration, give stop priority and require a fresh start after stopping completes. Follow documented behavior where arbitration is built into the controller.

Do not automatically retry an uncertain start. First determine whether the project started despite a missing acknowledgement. After reconnecting or resetting a fault, reconcile actual state and require the appropriate deliberate operating command.

Budget timeouts for the transition being monitored

Separate command-response timing from project preparation timing. Loading a project and acknowledging a start request are different operations, so they should not share an unexplained timeout.

For sequential preparation, a conservative deadline estimate is:

Consider an illustrative trace with 40 ms communication allowance, 800 ms loading, 300 ms initialization and 100 ms start acknowledgement allowance. Adding 260 ms margin gives:

40 + 800 + 300 + 100 + 260 = 1500 ms

That is a commissioning example, not a recommended universal timeout. Measure repeated cold starts, warm restarts and project changes under expected operating conditions.

Report which stage timed out. A message such as “initialization incomplete” directs investigation better than a single generic start fault. A timeout should also leave the application in a defined state rather than silently issuing another start.

Verify licensed capabilities before adding a background task

A separate handshake task can be useful when it must remain active while project execution stops. However, independent task execution may depend on controller software, installed options, runtime licensing or application restrictions.

Before assigning that architecture, verify:

• The exact controller and runtime version.
• The installed entitlement for concurrent or background tasks, if required.
• Whether the application permits an additional user task.
• Which communications and I/O resources that task may own.
• How task startup, shutdown and project changes are coordinated.

A vision application entitlement does not establish that every controller programming feature is included. Confirm the requirement through the manufacturer's documentation or authorized support channel.

If the capability is unavailable, use a documented alternative: PLC-side sequencing through supported status signals, an approved application service, or an appropriately licensed controller configuration. Do not alter protected runtime components or try to circumvent an entitlement check.

For operator-driven selection, keep the lifecycle handshake separate from the selection mechanism described in local vision recipe switching from operator buttons.

Check hardware roles without treating hardware as the fix

When specifying a new cell, distinguish vision controllers from smart cameras. Confirm where project management executes and which device owns each status signal. Neither category alone establishes support for your handshake or licensed task architecture.

The MV-SVC2506-16G60-128G is a vision controller candidate. Verify its documented runtime capabilities and project interface against the required lifecycle.

The MV-SC3013XM-12M-ATN-H is a vision sensor candidate. Confirm its application command and status interface before assigning it a role in the handshake.

Use the camera finder to review imaging requirements separately from controller execution requirements. Replacing hardware is not the first remedy when the missing transition is loading, initialization or command acknowledgement.

Validate restart behavior and preserve the evidence

Complete an acceptance checklist before returning the cell to normal operation:

• Cold startup: loading and initialization finish before start becomes eligible.
• Ordinary stop and restart: stopping completes, the request rearms, and a fresh start is recognized.
• Start while not ready: the documented interface rejects, ignores or otherwise handles it predictably, without a surprise later start.
• Initialization fault: the PLC receives a useful fault indication and does not retry indefinitely.
• Communication interruption: commands do not become stale requests after reconnection.
• Project change: identity, readiness and command ownership agree before starting.
• Simultaneous commands: observed arbitration matches the documented design.

Keep a known-good trace with signal assignments, interface semantics, timeout values, software versions and required entitlements. Repeat these checks after relevant application or runtime changes.

If a transition remains unexplained, send the state trace, project identity and diagnostic messages through technical support. Start with the first missing acknowledgement or state transition, not a request for a longer start pulse.