{powered ? "⚙️" : "🛑"}

Axis.Status = {status}

.bEnabled = {powered ? "TRUE" : "FALSE"}{"\n"} .ActPos = 0.0 mm{"\n"} .ActVelocity = 0.0

{powered ? <>Powered and idle — status is Standstill, the green light to command a move. The shaft holds position under control. : !enable ? <>Disabled. MC_Power.Enable is FALSE, so the drive is off and any move command is ignored. : <>Enabled but the regulator is off — the axis can't hold torque. Flip bRegulatorOn back to TRUE.}

VAR{"\n"}
  Axis     : AXIS_REF;   {`// the motor + encoder, by reference`}{"\n"}
  fbPower  : MC_Power;{"\n"}
END_VAR{"\n\n"}
fbPower(Axis := Axis, Enable := bDriveOn, bRegulatorOn := TRUE, bDriveStart := TRUE);{"\n"}
bAxisReady := fbPower.Status;   {`// TRUE once Standstill`}

Every motion FB takes the same Axis : AXIS_REF as its first input — that's how they all talk to the same physical drive. Call MC_Power every scan to keep it enabled. Axis states are a fixed PLCopen set: Disabled → Standstill → Moving → …. A move is only legal from Standstill (or while already moving).

); }, }); // ════════════════════════════════════════════════════════════════ // CH2 — Absolute vs relative moves // ════════════════════════════════════════════════════════════════ defineChapter({ id: "moves", act: "PLCopen · Moves", num: 2, emoji: "🎯", navTitle: "Absolute vs relative", title: "Moves: go TO a spot, or go BY a step", sub: "MC_MoveAbsolute sends the axis to a fixed coordinate — position 350, no matter where it started. MC_MoveRelative shifts it BY an amount from wherever it is now. Same axis, two very different mental models.", Body: function MovesBody() { const RAIL = 500; const [pos, setPos] = uM(120); const posRef = rM(120); const [busy, setBusy] = uM(false); const [done, setDone] = uM(true); const [vel, setVel] = uM(220); const [target, setTarget] = uM(350); const raf = rM(null); eM(() => () => cancelAnimationFrame(raf.current), []); const animateTo = (tgt) => { tgt = Math.max(0, Math.min(RAIL, tgt)); cancelAnimationFrame(raf.current); const from = posRef.current; const dist = tgt - from; if (Math.abs(dist) < 0.5) { setDone(true); return; } const dur = Math.max(250, Math.abs(dist) / vel * 1000); const t0 = performance.now(); setBusy(true); setDone(false); const tick = (now) => { const k = Math.min(1, (now - t0) / dur); const e = k < 0.5 ? 2 * k * k : 1 - Math.pow(-2 * k + 2, 2) / 2; const cur = from + dist * e; posRef.current = cur; setPos(cur); if (k < 1) raf.current = requestAnimationFrame(tick); else { posRef.current = tgt; setPos(tgt); setBusy(false); setDone(true); } }; raf.current = requestAnimationFrame(tick); }; const pctPos = (pos / RAIL) * 100; const pctTgt = (target / RAIL) * 100; return (

{/* target ghost */}

target {Math.round(target)}

{/* rail */}

{/* carriage */}

🔩

{/* scale ends */}

{RAIL}

Axis.ActPos = {pos.toFixed(1)} mm · Busy = {busy ? "TRUE" : "FALSE"} · Done = {done ? "TRUE" : "FALSE"}

Target position {Math.round(target)} mm

setTarget(parseInt(e.target.value, 10))} style={{ width: "100%", accentColor: "var(--coral)" }} />

Velocity {vel} mm/s

setVel(parseInt(e.target.value, 10))} style={{ width: "100%", accentColor: "var(--mint)" }} />

Absolute always lands on the dashed target, wherever it began. Relative jumps ±80 from the carriage's current spot — run it twice and it keeps stepping. That's the whole difference.

fbMoveAbs(Axis:=Axis, Execute:=bGo, Position:=350.0, Velocity:={vel}.0);  {`// to 350`}{"\n"}
fbMoveRel(Axis:=Axis, Execute:=bStep, Distance:=80.0, Velocity:={vel}.0);  {`// by +80`}{"\n"}
IF fbMoveAbs.Done THEN eStep := eStep + 1; END_IF   {`// Done is a one-shot pulse`}

Execute is rising-edge triggered — the move fires when it goes FALSE→TRUE. Done pulses TRUE for one cycle when the target is reached; latch it if you need to remember. Absolute moves only mean anything once the axis is homed — position 350 is relative to a zero you haven't set yet. That's the next-but-one chapter.

); }, }); // ════════════════════════════════════════════════════════════════ // CH3 — Motion profile // ════════════════════════════════════════════════════════════════ defineChapter({ id: "profile", act: "PLCopen · Moves", num: 3, emoji: "📈", navTitle: "The motion profile", title: "The profile: ramp up, cruise, ramp down", sub: "A move isn't instant. The axis accelerates to velocity, cruises, then decelerates to a stop — a trapezoid. Push the distance too short and it never reaches full speed: the trapezoid collapses into a triangle.", Body: function ProfileBody() { const [vel, setVel] = uM(300); // mm/s const [acc, setAcc] = uM(800); // mm/s² const [dist, setDist] = uM(300); // mm const tRamp = vel / acc; const dRamp = (vel * vel) / (2 * acc); let trapezoid, peak, tTotal, pts; if (2 * dRamp >= dist) { trapezoid = false; peak = Math.sqrt(dist * acc); const tr = peak / acc; tTotal = 2 * tr; pts = [[0, 0], [tr, peak], [tTotal, 0]]; } else { trapezoid = true; peak = vel; const dCruise = dist - 2 * dRamp; const tCruise = dCruise / vel; tTotal = 2 * tRamp + tCruise; pts = [[0, 0], [tRamp, vel], [tRamp + tCruise, vel], [tTotal, 0]]; } const W = 380, H = 150, PADL = 8, PADB = 8; const maxV = Math.max(peak, vel) * 1.08; const sx = (W - PADL) / tTotal, sy = (H - PADB) / maxV; const X = (t) => PADL + t * sx; const Y = (v) => H - PADB - v * sy; const poly = pts.map(p => `${X(p[0]).toFixed(1)},${Y(p[1]).toFixed(1)}`).join(" "); return (

velocity →

{[["Set velocity", vel, setVel, 60, 500, 10, "mm/s", "var(--coral)"], ["Acceleration", acc, setAcc, 100, 2500, 50, "mm/s²", "var(--mint)"], ["Distance", dist, setDist, 30, 500, 10, "mm", "var(--blue)"]].map(([lbl, val, set, mn, mx, st, unit, col], i) => (

{lbl} {val} {unit}

set(parseInt(e.target.value, 10))} style={{ width: "100%", accentColor: col }} />

))}

peak velocity = {peak.toFixed(0)} mm/s {!trapezoid && (capped — distance too short)}{"\n"} total time = {tTotal.toFixed(2)} s · shape = {trapezoid ? "trapezoid" : "triangle"}

Crank distance down or acceleration down and watch the trapezoid pinch into a triangle — there isn't room to reach the set velocity before it must start braking.

Every move FB takes Velocity, Acceleration, Deceleration and Jerk. They shape the ramp — higher accel = faster but harsher; jerk-limiting rounds the corners to spare the mechanics. For short index moves you often can't hit the set velocity. That's normal — the drive plans the fastest legal triangle and still reports Done.

); }, }); // ════════════════════════════════════════════════════════════════ // CH4 — Homing & jogging // ════════════════════════════════════════════════════════════════ defineChapter({ id: "homing", act: "PLCopen · Reference", num: 4, emoji: "🏠", navTitle: "Homing & jogging", title: "Homing & jogging: find zero, nudge by hand", sub: "An absolute position means nothing until the axis knows where zero is. Homing drives to a reference switch and sets the datum. Jogging is the manual override — hold a button to inch the axis while you set up.", Body: function HomingBody() { const RAIL = 500; const [pos, setPos] = uM(280); const posRef = rM(280); const [homed, setHomed] = uM(false); const [homing, setHoming] = uM(false); const raf = rM(null); const jogInt = rM(null); eM(() => () => { cancelAnimationFrame(raf.current); clearInterval(jogInt.current); }, []); const home = () => { if (homing) return; cancelAnimationFrame(raf.current); clearInterval(jogInt.current); setHoming(true); setHomed(false); const from = posRef.current, dur = Math.max(500, from / 260 * 1000), t0 = performance.now(); const tick = (now) => { const k = Math.min(1, (now - t0) / dur); const cur = from * (1 - k); posRef.current = cur; setPos(cur); if (k < 1) raf.current = requestAnimationFrame(tick); else { posRef.current = 0; setPos(0); setHoming(false); setHomed(true); } }; raf.current = requestAnimationFrame(tick); }; const jog = (dir) => { if (homing) return; clearInterval(jogInt.current); jogInt.current = setInterval(() => { const next = Math.max(0, Math.min(RAIL, posRef.current + dir * 6)); posRef.current = next; setPos(next); }, 16); }; const stopJog = () => clearInterval(jogInt.current); const status = homing ? "HOMING" : homed ? "HOMED" : "NOT HOMED"; const sColor = homing ? "var(--yellow)" : homed ? "var(--mint)" : "var(--coral)"; const pctPos = (pos / RAIL) * 100; return (

🚩

ref switch = 0

🔩

Axis.ActPos = {homed || homing ? {pos.toFixed(1)} mm : undefined — not homed} · Status = {status}

{homing ? <>Seeking the reference switch… the drive creeps toward the flag and will latch zero when it hits. : homed ? <>Homed ✓ — position is now absolute and trustworthy. Absolute moves finally mean what they say. : <>Before homing, ActPos is meaningless — the axis has no idea where zero is. Press MC_Home, or hold a Jog to nudge it by hand.}

fbHome(Axis:=Axis, Execute:=bDoHome, Position:=0.0);   {`// seek switch, set datum`}{"\n"}
bReady := Axis.Status.Homed;{"\n\n"}
fbJogFwd(Axis:=Axis, JogForward:=bBtnPlus, Velocity:=25.0);   {`// hold to inch`}

Homing establishes the zero datum. Incremental encoders forget zero on every power-off, so they re-home at startup. Absolute encoders remember and may home only once. Jog ignores the soft target but still respects limit switches and software limits — manual doesn't mean reckless. Keep velocities low while setting up.

); }, }); // ════════════════════════════════════════════════════════════════ // CH5 — Analog I/O & scaling // ════════════════════════════════════════════════════════════════ defineChapter({ id: "scaling", act: "Real World · Sensors", num: 5, emoji: "🌡️", navTitle: "Analog & scaling", title: "Analog & scaling: raw counts → real units", sub: "A sensor doesn't hand you '7.4 bar'. The terminal gives a raw integer — 0…32767. Your job is the linear map from counts to engineering units, and to notice when a 4–20 mA loop drops out and a wire has broken.", Body: function ScalingBody() { const PRESETS = { temp: { label: "0–10 V temp probe", rawLo: 0, rawHi: 32767, euLo: 0, euHi: 250, unit: "°C", faultLo: -1 }, pres: { label: "4–20 mA pressure", rawLo: 6553, rawHi: 32767, euLo: 0, euHi: 10, unit: "bar", faultLo: 5800 }, }; const [key, setKey] = uM("temp"); const [raw, setRaw] = uM(16000); const p = PRESETS[key]; const fault = raw < p.faultLo; const clampedRaw = Math.max(p.rawLo, Math.min(p.rawHi, raw)); const eu = (clampedRaw - p.rawLo) / (p.rawHi - p.rawLo) * (p.euHi - p.euLo) + p.euLo; const euPct = (eu - p.euLo) / (p.euHi - p.euLo) * 100; return (

{Object.entries(PRESETS).map(([k, v]) => ( ))}

Raw count from terminal {raw}

setRaw(parseInt(e.target.value, 10))} style={{ width: "100%", accentColor: "var(--blue)" }} />

{fault ? "⚠ wire break / under-range" : `${eu.toFixed(1)} ${p.unit}`}

{p.euLo} {p.unit}{p.euHi} {p.unit}

{fault ? <>On a 4–20 mA loop, 0 mA means the wire is cut — the raw count sits below the live range, so you flag a fault instead of reporting a fake 0 bar. : <>Raw {raw} maps linearly to {eu.toFixed(1)} {p.unit}. Slide toward 0 on the 4–20 mA sensor to trip the broken-wire detector.}

{`// linear scale: counts -> engineering units (LREAL math)`}{"\n"}
rValue := INT_TO_LREAL(nRaw - nRawLo) / (nRawHi - nRawLo){"\n"}
        * (rEuHi - rEuLo) + rEuLo;{"\n\n"}
IF nRaw < nFaultLo THEN bWireBreak := TRUE; END_IF   {`// 4-20mA dropout`}

The scale is just y = m·x + c across two known points: (rawLo→euLo) and (rawHi→euHi). Do the maths in LREAL so integer division doesn't quietly truncate. Prefer 4–20 mA over 0–10 V for anything important: a cut wire reads 0 mA, which is outside the live band — so you can tell the sensor failed instead of trusting a false zero.

That's Track 07 — you can enable an axis, command absolute and relative moves, shape a profile, home and jog, and turn raw counts into trustworthy units. Motion is where logic finally meets the machine. Back to the Academy!

); }, });