Instructions Workbench

Id: instructions · Thirteenth entry in the workbench dropdown

Instructions writes manufacturing (assembly) instructions: how an assembly is put together, step by step, for the shop floor and for customers. Instructions are their own document (.ibrep), separate from the assembly they describe, and are revised on their own schedule.

What it offers

Instructions create no features: the Add-feature palette is empty here. The workbench adds:

• the Instructions pane: the step tree (a step's children indented under it) and the selected step's editor;
• the Player pane, which plays the steps (below);
• four toolbar buttons (the table below). New from assembly, Wizard and New step are always on the row; one that cannot act on the open document is greyed, and its tooltip says why. Play joins the row only while instructions are open.

Making instructions

Open the assembly (saved: the instructions describe a saved revision) and press New from assembly. A new tab opens holding the instructions, in this workbench: the assembly is placed as one grounded component, and the wizard proposes the steps once it is built:

• a sub-assembly is one step in its parent, with the steps that build it as that step's children: they come first, then the step places the finished sub-assembly;
• the parts follow the mate order (or, when the assembly has an exploded view, that view's steps in reverse), one step per component;
• fasteners come last, one step per fastener part with all its occurrences, and the step's torque comes from the part.

A part is a fastener when its Fastener part property is true; its Torque property (text such as 12 N·m) is the step's default torque. Serial_Tracked marks a part whose serial number is captured on the shop floor at the step that adds it.

Wizard proposes the steps again, replacing the step tree (the template and front matter stay).

Planning by hand: parts from the BOM into steps

The wizard's steps are a proposal. You can also plan from nothing (New from assembly with the wizard off, or after taking parts out of their steps): the pane lists the assembly's parts that are in no step yet under Not yet planned (a sub-assembly stands for its own parts until it is placed; a part inside a sub-assembly built step by step is listed when its own step lost it), and the BOM pane is on this workbench too: the first time instructions are open here, the Instructions pane moves into a column of its own beside the side strip with the BOM in front of the strip, so both are on screen (once; arrange them as you like afterwards). Drag a part from either list onto a step's row, or press Add to selected step: its occurrences join that step as one BOM row (a fastener brings its torque). A part already in a step, or inside a sub-assembly another step places, is left where it is and the pane says so, unless the step you drop on is inside that sub-assembly's group. Unplan on a part's row takes it out of every step.

Steps nest: drop a step's row on another step's row, or press Nest under previous / Unnest. Drop a step on Steps (top level) to move it and its children to the end of the top level. A step with children is a group: the children build it (and see only the group's own earlier parts), then the step installs the whole group. Steps keep their ids wherever they move.

Editing steps

Click a step to select it and show its view: the camera, the parts not placed yet hidden, the parts earlier steps placed ghosted (grey and see-through) so the parts it adds stand out, and a balloon with the find number on each part it adds. Leaving the workbench puts the view away. The buttons under the list move the step up or down among its siblings, nest it under the previous one or out of its group, merge the next step into it, or delete it once it has neither parts nor child steps.

Each step's view has a camera the workbench generates: it frames everything the step shows (the parts it adds and the ghosts placed before it) from its parent step's direction, or the isometric at the top level, and it is made again whenever the step's parts, its children or its place in the tree change. Capture camera keeps the camera as you see it in the viewport instead, through every edit, until Reset view goes back to the generated one (the PMI workbench's Update camera on a step's view captures it the same way). Explode offsets and the annotations you add to a step's view survive either way, and the HTML player draws the step with its explode offsets and its view's PMI too.

The editor below sets the step's:

• Title;
• Parts: each with its find number and quantity; To previous step and To next step move a part to the neighbouring step, and Split out gives it a step of its own;
• Torque: shown as from the part until you type one, which then is set on this step;
• Tools: name and spec (a tool typed here is marked not in the tools library until it is linked to one); a linked tool's picture from the library shows in the players;
• Callouts: Caution, Note and Check, each with its text and, under it, the part it points at: a Part field like every reference field in the application (Select picks the part in the viewport, its line's clears it). The pick takes a solid, and the field keeps the part's occurrence (the solid's name without its member): a component pick would name the wrapper that places the whole assembly, never a part of it. A part an earlier step placed (drawn as a ghost) can be picked too;
• Insertion arrows: the side a part comes in from and how far out it starts, played as a short move home by the instruction players, and under each the Part it moves, picked in the viewport the same way (one of the step's own parts; + Arrow starts with the first part without one, and clearing an arrow's part removes the arrow);
• Notes, and whether the step needs sign-off on the shop floor.

New step inserts an empty step after the selected one; move parts into it from its neighbours. Every edit is one undo step, and typing into one field is one undo step per field. An edit that changes which step adds what brings the step views up to date: the hidden parts and the balloons follow the parts, and each step keeps its camera and the annotations you added to its view.

A study's motion on a step

A step can play a motion study of the assembly instead of its insertion arrows: the Simulation workbench publishes a study (its baked frames are kept with the assembly), and the step editor's Motion row offers the assembly's published studies. Pick one and the step keeps its own copy of the frames, so the instructions play without the assembly at hand; takes it off. A study published before the assembly changed is greyed in the menu until it is published again, and one attached earlier keeps playing as it was. In the HTML player the step shows a timeline: arriving on the step plays the motion once, Replay plays it again, the scrubber and the space bar seek and pause; the step frames the whole assembly, and every other part is drawn ghosted while the clip moves what it moves.

Playing

Play opens the Player pane at the first step (or plays the shown step again). Back and Next go through the steps in reading order, a step's children before it; each step shows through its view, the parts earlier steps placed ghosted, and the parts it adds come in along their insertion arrows. Replay shows them coming in again. A BOM row, or a part from the Instructions pane's not yet planned list, dropped on the step's title joins the shown step, as a drop on the step's row does. The player has the two modes the HTML player has:

• Shop: large buttons for touch, the step's parts as a checklist (with a serial field per unit of a serial-tracked part), its tools, torque, callouts and notes, and Sign off step on a step that needs sign-off, once every part is ticked;
• Customer: the step's title, its parts by find number and quantity, its tools by name with their library pictures, and its callouts.

The ticks, serials and sign-offs belong to the build being played, not to the document: they do not mark it changed or enter undo.

Printing and pictures

The Print row at the top of the Instructions pane sets the page template with three dropdowns, drawn like a feature dialog's: Steps a page (1, 2 or 4), Orientation (Portrait or Landscape) and Paper (A4, A3, A2, A1, A0, Letter or Tabloid), and two checkboxes, whether the Parts list and Tools list print. Each change is one undo step.

PDF export prepares pictures in the background and shows progress in the status bar, so the application remains responsive. Editing the source document or switching tabs cancels the export; start it again when the intended document is ready. If exact geometry cannot be loaded or drawn, the export reports an error.

File ▸ Export ▸ Instructions ▸ PDF writes the printed instructions: a cover (the title, the assembly and its revision, and the cover step's picture, the last step unless the front matter names one), the parts list (find number, part, quantity and the step that first adds it), the tools list (each tool and the steps that use it; left out while no step uses a tool), then the steps. Every page carries the title and its page number. Each step's slot has its view on the left or above, drawn as a drawing sheet draws a PMI view (visible edges only, with its balloons), and beside or below it the step number and title, the parts it adds by find number and quantity, its tools, torque, callouts and notes. The parts the step adds are drawn in an orange, heavier line and the parts earlier steps placed in the plain black one, so what to install is clear on the page (and still in a black-and-white print). The step SVGs draw them the same way.

Step images writes every step's picture twice, in reading order (step-01-MS2.png, step-01-MS2.svg, …): the PNG from the step's camera, the parts it adds in their colours and the parts earlier steps placed in grey; the SVG with the step's number and title over its view as lines.

The files draw each step from its own view whatever the viewport shows: a step shown in the player, its ghosts and its insertion arrows do not change them. The step pictures draw every edge in one weight; the ghosting that tells earlier parts apart is in the PNG and the players, not in the PDF's or SVG's lines.

The offline player carries the linked tools' pictures inlined, fetched from the PLM tools library when the export is made (the export waits for them; without a session the page shows the tools by name alone). The player the PLM serves loads them from the library itself.

The PDF's and SVGs' lines are the exact hidden-line pass over every part's B-rep, which the export asks the kernel for first and waits for ("Loading exact geometry" on the busy line; in the browser the export runs once it has landed). The first export of a document loads that exact geometry, so it takes longer than the ones after it. Other export paths label any mesh approximation in the file: data-hidden-line on the SVG's view, /HiddenLine in the PDF's Info (instructions_export returns it as hiddenLine).

The offline player

File ▸ Export ▸ Instructions ▸ Player (HTML) writes the interactive player as one self-contained .html page that needs no server and fetches nothing: open it in any browser. Next and Back (or the arrow keys) go through the steps, with a live 3D view of each step from its view's camera. The parts the step adds are drawn in the highlight colour with their edges, and the parts earlier steps placed are ghosted. Parts with an insertion arrow come in along it, and plays that again. The view's controls are the CAD viewport's: a left drag turns the view, a middle or right drag pans it, and the wheel zooms toward the pointer; on a touch screen one finger turns the view and two fingers pinch and pan at once. The step's view PMI (its balloons, dimensions, notes, hole callouts and leaders) is drawn over the parts in the viewport's PMI colour, laid out as the 3D PDF lays it out; PMI in the footer hides and shows it. The page is the shop mode: a checklist of the steps beside the view, and Mark step done on each step that wants a sign-off. A browser without WebGL shows each step's picture instead, with the view's annotation texts listed beside it (the picture does not draw them).

Beside Steps, two tabs work outside the steps:

• Model shows the whole assembly with the assembly tree beside it. Sub-assemblies open and close (Expand and Collapse do all of them); each component's box shows or hides it (a sub-assembly with everything in it, and showing a part inside a hidden sub-assembly shows that part alone); Show all, Hide all and Fit act on the whole model. Picking a component highlights it and lists its details and the steps it is used in; double-click fits it, and Isolate hides everything else.
• Parts is a card per part: its thumbnail, find numbers, quantity, torque, its part attributes (description, material …) and a button per step that uses it, which opens that step. Show in model opens the Model tab with only that part's occurrences shown. The filter box narrows the cards by name, part id, find number or attribute; clicking a part in a step's list opens its card. The file is named for the instructions (valve.html, like valve.pdf and valve-steps.zip): an instructions tab not saved yet takes its title, a saved one its file's stem.

A PLM server serves the same page per instructions revision, signed in for shop mode (sign-off goes to the job) and through a customer link for customer mode (pictures and parts, no checklist).

Saving instructions to a PLM revision also sends the server the player's data, made from what was just saved. The page the server serves shows that data, and a release of the instructions needs it to be from the document the revision holds. If the revision changed in between, a notice says "player data is from a different document": save again from the app.

A new revision of the assembly

Instructions describe one revision of their assembly. When the assembly changes (a new revision saved, then Update components on the instructions, or the assembly edited in another open tab), the instructions follow it in the same undo step, and the wizard reruns on the changed parts only. A part the new revision adds gets a step of its own after the step that adds a part it is mated to. A part it removes leaves its step, and a step left with no parts says so. A part replaced by another takes the new part in its step. Find numbers follow the new revision everywhere.

Until you approve the change, the top of the Instructions pane lists the parts added, removed and replaced, and the steps they changed (click one to see it). Approve the new revision makes it the instructions' target and deletes the steps left with no parts. Another update is refused until you approve, and a PLM release of the instructions waits for it too. Reject: take the revision back is the one Undo that takes the new revision and these changes back together, so the instructions keep describing the revision they did (Redo brings the update back). It is refused while an edit sits on top of the update (undo that first, or approve) and for a re-target that came in with the file, which nothing in this session can take back: approve it, or update again later.

Where the data lives

The instructions document's instructions block: the target assembly revision, the page template, the front matter, a re-target waiting for approval (retarget), and the step tree (steps, each step with its steps), each step with its parts (adds: occurrences, part (the PLM part id when the part came from a PLM revision, else its name), name (the display name, when it differs), find number), view, tools, torque, callouts, arrows, notes and sign-off. Each step's view is a PMI view of the document. The block is schema 2; a schema-1 document (chapters of steps) reads as the same tree, a sub-assembly's chapter under the step that places it, and is written back as schema 2 on the next edit.

Toolbar buttons

Automation

Every action is a command: instructions_state, instructions_new, instructions_wizard, instructions_show_step, instructions_update_step, instructions_merge, instructions_split, instructions_new_step, instructions_move_step, instructions_move_add, instructions_delete_step, instructions_retarget_approve, instructions_retarget_reject, instructions_update (the page template and front matter), instructions_motions, instructions_attach_motion and instructions_detach_motion (a published study's motion on a step), instructions_play (the player's step and mode) and instructions_export (the PDF, one step's PNG or SVG, every step's pictures in a zip, or the offline player's page), beside workbench_button for the four buttons. The __brepInstructions state blob carries the pane's selected step and last notice; __brepInstructionsHit carries the pane's rects (instructions:*, the Print row's instructions:print:*, the waiting re-target's instructions:retarget:*). __brepInstructionsPlayer carries the player's mode, ticks, serials and sign-offs, and __brepInstructionsPlayerHit its rects (player:*). The instructions-wizard, instructions-workbench, instructions-pick (the occurrence fields' viewport picks), instructions-player, instructions-export, instructions-html, instructions-motion and instructions-retarget scripts in the MCP suite drive it, and verify_instructions_html.mjs and verify_instructions_motion.mjs drive the exported pages in a browser.