Implement AXIS parity UI and execution baseline
This commit is contained in:
266
web/worker/hal-runtime.mjs
Normal file
266
web/worker/hal-runtime.mjs
Normal file
@@ -0,0 +1,266 @@
|
||||
import { fnv1a64 } from "./replay.mjs";
|
||||
|
||||
export const HAL_RUNTIME_SCHEMA = "sim_hal_runtime.v1";
|
||||
const MAX_PIN_COUNT = 256;
|
||||
const MAX_PARAM_COUNT = 256;
|
||||
const MAX_COMPONENT_COUNT = 64;
|
||||
const MAX_THREAD_COUNT = 16;
|
||||
const MAX_PERIOD_TICKS = 1000000;
|
||||
|
||||
const TYPE_NAMES = new Set(["bit", "s32", "u32", "float"]);
|
||||
const NAME_RE = /^[A-Za-z_][A-Za-z0-9_.-]{0,46}$/;
|
||||
|
||||
const SPEC = Object.freeze({
|
||||
corexy_by_hal: { pins: { "j0-motor-pos-cmd": "float", "j1-motor-pos-cmd": "float", "alpha-cmd": "float", "beta-cmd": "float", "alpha-fb": "float", "beta-fb": "float", "j0-motor-pos-fb": "float", "j1-motor-pos-fb": "float" }, params: {} },
|
||||
constant: { pins: { out: "float" }, params: { value: ["float", 0] } },
|
||||
and2: { pins: { in0: "bit", in1: "bit", out: "bit" }, params: {} },
|
||||
or2: { pins: { in0: "bit", in1: "bit", out: "bit" }, params: {} },
|
||||
xor2: { pins: { in0: "bit", in1: "bit", out: "bit" }, params: {} },
|
||||
not: { pins: { in: "bit", out: "bit" }, params: {} },
|
||||
abs: { pins: { in: "float", out: "float", sign: "bit", "is-positive": "bit", "is-negative": "bit" }, params: {} },
|
||||
abs_s32: { pins: { in: "s32", out: "s32", sign: "bit", "is-positive": "bit", "is-negative": "bit" }, params: {} },
|
||||
lowpass: { pins: { in: "float", out: "float", load: "bit" }, params: { gain: ["float", 0] } },
|
||||
ddt: { pins: { in: "float", out: "float" }, params: {} },
|
||||
integ: { pins: { in: "float", gain: "float", out: "float", reset: "bit", max: "float", min: "float" }, params: {} },
|
||||
mux2: { pins: { sel: "bit", out: "float", in1: "float", in0: "float" }, params: {} },
|
||||
sum2: { pins: { in0: "float", in1: "float", out: "float" }, params: { gain0: ["float", 1], gain1: ["float", 1], offset: ["float", 0] } },
|
||||
mult2: { pins: { in0: "float", in1: "float", out: "float" }, params: {} },
|
||||
div2: { pins: { in0: "float", in1: "float", out: "float" }, params: { deadband: ["float", 0] } },
|
||||
hypot: { pins: { in0: "float", in1: "float", in2: "float", out: "float" }, params: {} },
|
||||
near: { pins: { in1: "float", in2: "float", out: "bit" }, params: { scale: ["float", 1], difference: ["float", 0] } },
|
||||
comp: { pins: { in0: "float", in1: "float", out: "bit", equal: "bit" }, params: { hyst: ["float", 0] } },
|
||||
invert: { pins: { in: "float", out: "float" }, params: { deadband: ["float", 0] } },
|
||||
edge: { pins: { in: "bit", out: "bit", "out-invert": "bit" }, params: { both: ["bit", 0], "in-edge": ["bit", 1], "out-width-ns": ["s32", 0], "time-left-ns": ["s32", 0], "last-in": ["bit", 0] } },
|
||||
toggle: { pins: { in: "bit", out: "bit" }, params: { debounce: ["u32", 2] } },
|
||||
estop_latch: { pins: { "ok-in": "bit", "fault-in": "bit", reset: "bit", "ok-out": "bit", "fault-out": "bit", watchdog: "bit" }, params: {} },
|
||||
});
|
||||
|
||||
const clone = (value) => structuredClone(value);
|
||||
const validName = (value) => typeof value === "string" && NAME_RE.test(value);
|
||||
const finite = (value) => typeof value === "number" && Number.isFinite(value);
|
||||
const normalizeType = (value) => value === "signed" ? "s32" : value === "unsigned" ? "u32" : value;
|
||||
|
||||
function valueFor(type, value = 0) {
|
||||
if (!TYPE_NAMES.has(type) || (type === "bit" && ![0, 1, false, true].includes(value)) || !finite(type === "bit" ? Number(value) : value)) throw new Error("hal_value_invalid");
|
||||
if (type === "bit") return value ? 1 : 0;
|
||||
if (type === "s32") {
|
||||
if (!Number.isSafeInteger(value) || value < -2147483648 || value > 2147483647) throw new Error("hal_s32_range");
|
||||
return value;
|
||||
}
|
||||
if (type === "u32") {
|
||||
if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) throw new Error("hal_u32_range");
|
||||
return value;
|
||||
}
|
||||
return Number(value);
|
||||
}
|
||||
|
||||
function qualified(instance, suffix) {
|
||||
if (!validName(instance) || !validName(suffix) || instance.length + suffix.length + 1 > 47) throw new Error("hal_name_invalid");
|
||||
return `${instance}.${suffix}`;
|
||||
}
|
||||
|
||||
export function parseCompSource(source) {
|
||||
if (typeof source !== "string" || source.length === 0 || source.length > 1024 * 1024) return { status: "blocked", code: "hal_comp_source_invalid" };
|
||||
const lines = source.split(/\r?\n/);
|
||||
let component = null;
|
||||
const pins = [];
|
||||
const params = [];
|
||||
const functions = [];
|
||||
const options = [];
|
||||
const errors = [];
|
||||
for (let index = 0; index < lines.length; index += 1) {
|
||||
const line = lines[index].replace(/\/\/.*$/, "").trim();
|
||||
let match = /^component\s+([A-Za-z_][A-Za-z0-9_]*)\b/.exec(line);
|
||||
if (match) { if (component && component !== match[1]) errors.push(`duplicate_component:${index + 1}`); component = match[1]; continue; }
|
||||
match = /^pin\s+(in|out|io)\s+([A-Za-z_][A-Za-z0-9_]*)\s+([A-Za-z_][A-Za-z0-9_.#-]*)/.exec(line);
|
||||
if (match) { const type = normalizeType(match[2]); if (!TYPE_NAMES.has(type)) errors.push(`hal_type_unsupported:${index + 1}`); pins.push({ direction: match[1], type, name: match[3], line: index + 1 }); continue; }
|
||||
match = /^param\s+(r|rw)\s+([A-Za-z_][A-Za-z0-9_]*)\s+([A-Za-z_][A-Za-z0-9_.-]*)(?:\s*=\s*([^\s]+))?/.exec(line);
|
||||
if (match) { const type = normalizeType(match[2]); if (!TYPE_NAMES.has(type)) errors.push(`hal_type_unsupported:${index + 1}`); params.push({ mode: match[1], type, name: match[3], default: match[4] ?? null, line: index + 1 }); continue; }
|
||||
match = /^function\s+([^;]+);/.exec(line);
|
||||
if (match) functions.push(...match[1].split(/\s+/).filter(Boolean).map((name) => ({ name, line: index + 1 })));
|
||||
match = /^option\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s*=\s*([^\s]+))?/.exec(line);
|
||||
if (match) options.push({ name: match[1], value: match[2] ?? null, line: index + 1 });
|
||||
}
|
||||
if (!component) errors.push("hal_component_missing");
|
||||
const names = [...pins, ...params].map((item) => item.name);
|
||||
if (new Set(names).size !== names.length) errors.push("hal_declaration_duplicate");
|
||||
if (component && !SPEC[component]) errors.push("hal_component_unsupported");
|
||||
return { schema: "hal-component-source.v1", status: errors.length ? "blocked" : "verified", ...(errors.length ? { code: errors[0].split(":", 1)[0] } : {}), component, pins, params, functions, options, errors };
|
||||
}
|
||||
|
||||
export class HalRuntime {
|
||||
constructor() { this.reset(); }
|
||||
|
||||
reset() {
|
||||
this.state = { schema: HAL_RUNTIME_SCHEMA, tick: 0, threads: {}, pins: {}, params: {}, components: [], links: [], last_error: null };
|
||||
return this.export();
|
||||
}
|
||||
|
||||
export() { const unsigned = clone(this.state); return { ...unsigned, state_hash: fnv1a64(unsigned) }; }
|
||||
hash() { return this.export().state_hash; }
|
||||
fail(code, detail = null) { this.state.last_error = code; return { status: "error", code, ...(detail ? { detail } : {}), state: this.export() }; }
|
||||
ok(command) { this.state.last_error = null; return { status: "verified", command, state: this.export() }; }
|
||||
|
||||
registerThread(name, period_ticks) {
|
||||
if (!validName(name) || !Number.isSafeInteger(period_ticks) || period_ticks < 1 || period_ticks > MAX_PERIOD_TICKS) return this.fail("hal_thread_invalid");
|
||||
if (this.state.threads[name]) return this.fail("hal_thread_duplicate");
|
||||
if (Object.keys(this.state.threads).length >= MAX_THREAD_COUNT) return this.fail("hal_thread_capacity");
|
||||
this.state.threads[name] = { name, period_ticks };
|
||||
return this.ok("HAL_THREAD");
|
||||
}
|
||||
|
||||
registerComponent(instance, type, thread = "servo-thread") {
|
||||
if (!validName(instance) || !validName(type) || !validName(thread)) return this.fail("hal_component_name");
|
||||
if (!SPEC[type]) return this.fail("hal_component_unsupported");
|
||||
if (!this.state.threads[thread]) return this.fail("hal_thread_missing");
|
||||
if (this.state.components.some((component) => component.instance === instance)) return this.fail("hal_component_duplicate");
|
||||
if (this.state.components.length >= MAX_COMPONENT_COUNT) return this.fail("hal_component_capacity");
|
||||
const spec = SPEC[type];
|
||||
const before = clone(this.state);
|
||||
try {
|
||||
const component = { instance, type, thread, calls: 0, failed: false, memory: [0, 0, 0, 0], flags: [0, 0, 0, 0] };
|
||||
for (const [suffix, pinType] of Object.entries(spec.pins)) {
|
||||
const name = qualified(instance, suffix);
|
||||
if (this.state.pins[name] || this.state.params[name]) throw new Error("hal_pin_duplicate");
|
||||
if (Object.keys(this.state.pins).length >= MAX_PIN_COUNT) throw new Error("hal_pin_capacity");
|
||||
this.state.pins[name] = { name, type: pinType, value: valueFor(pinType) };
|
||||
}
|
||||
for (const [suffix, [paramType, initial]] of Object.entries(spec.params)) {
|
||||
const name = qualified(instance, suffix);
|
||||
if (this.state.pins[name] || this.state.params[name]) throw new Error("hal_param_duplicate");
|
||||
if (Object.keys(this.state.params).length >= MAX_PARAM_COUNT) throw new Error("hal_param_capacity");
|
||||
this.state.params[name] = { name, type: paramType, value: valueFor(paramType, initial) };
|
||||
}
|
||||
if (type === "integ") {
|
||||
this.state.pins[qualified(instance, "gain")].value = 1;
|
||||
this.state.pins[qualified(instance, "max")].value = 1e20;
|
||||
this.state.pins[qualified(instance, "min")].value = -1e20;
|
||||
}
|
||||
if (type === "estop_latch") {
|
||||
this.state.pins[qualified(instance, "ok-in")].value = 1;
|
||||
this.state.pins[qualified(instance, "fault-out")].value = 1;
|
||||
}
|
||||
this.state.components.push(component);
|
||||
return this.ok("HAL_COMPONENT");
|
||||
} catch (error) {
|
||||
this.state = before;
|
||||
return this.fail(error.message);
|
||||
}
|
||||
}
|
||||
|
||||
configure({ threads = [], components = [], links = [] } = {}) {
|
||||
if (!Array.isArray(threads) || !Array.isArray(components) || !Array.isArray(links)) return this.fail("hal_config_invalid");
|
||||
this.reset();
|
||||
if (!threads.length) threads = [{ name: "servo-thread", period_ticks: 1 }];
|
||||
for (const thread of threads) { const result = this.registerThread(thread?.name, thread?.period_ticks); if (result.status === "error") return result; }
|
||||
for (const component of components) {
|
||||
const instances = Array.isArray(component?.instances) && component.instances.length ? component.instances : [component?.instance ?? component?.name ?? component?.module];
|
||||
for (const instance of instances) {
|
||||
const result = this.registerComponent(instance, component?.type ?? component?.module, component?.thread ?? "servo-thread");
|
||||
if (result.status === "error") return result;
|
||||
}
|
||||
}
|
||||
for (const link of links) { const result = this.connect(link?.source, link?.target); if (result.status === "error") return result; }
|
||||
return this.ok("HAL_CONFIG");
|
||||
}
|
||||
|
||||
setValue(collection, name, value, type = undefined) {
|
||||
const entry = this.state[collection][name];
|
||||
if (!entry) return this.fail("hal_value_missing");
|
||||
const normalized = value && typeof value === "object" && !Array.isArray(value) ? value.value : value;
|
||||
const requestedType = value && typeof value === "object" && !Array.isArray(value) ? value.type : type;
|
||||
if (requestedType !== undefined && normalizeType(requestedType) !== entry.type) return this.fail("hal_value_type");
|
||||
try { entry.value = valueFor(entry.type, normalized); } catch (error) { return this.fail(error.message); }
|
||||
return this.ok(collection === "pins" ? "HAL_SET_PIN" : "HAL_SET_PARAM");
|
||||
}
|
||||
|
||||
setPin(name, value, type = undefined) { return this.setValue("pins", name, value, type); }
|
||||
setParam(name, value, type = undefined) { return this.setValue("params", name, value, type); }
|
||||
getPin(name) { return this.state.pins[name] ? clone(this.state.pins[name]) : null; }
|
||||
getParam(name) { return this.state.params[name] ? clone(this.state.params[name]) : null; }
|
||||
|
||||
connect(source, target) {
|
||||
if (!this.state.pins[source] || !this.state.pins[target]) return this.fail("hal_connection_missing");
|
||||
if (this.state.pins[source].type !== this.state.pins[target].type) return this.fail("hal_connection_type");
|
||||
if (this.state.links.some((link) => link.source === source && link.target === target)) return this.fail("hal_connection_duplicate");
|
||||
this.state.links.push({ source, target });
|
||||
this.state.pins[target].value = this.state.pins[source].value;
|
||||
return this.ok("HAL_CONNECT");
|
||||
}
|
||||
|
||||
setFailure(instance, failed = true) {
|
||||
const component = this.state.components.find((item) => item.instance === instance);
|
||||
if (!component) return this.fail("hal_component_missing");
|
||||
component.failed = Boolean(failed);
|
||||
return this.ok("HAL_FAILURE");
|
||||
}
|
||||
|
||||
readPin(component, suffix) { return this.state.pins[qualified(component.instance, suffix)].value; }
|
||||
writePin(component, suffix, value) { const pin = this.state.pins[qualified(component.instance, suffix)]; pin.value = valueFor(pin.type, value); }
|
||||
readParam(component, suffix) { return this.state.params[qualified(component.instance, suffix)].value; }
|
||||
writeParam(component, suffix, value) { const param = this.state.params[qualified(component.instance, suffix)]; param.value = valueFor(param.type, value); }
|
||||
|
||||
runComponent(component) {
|
||||
const p = (suffix) => this.readPin(component, suffix);
|
||||
const w = (suffix, value) => this.writePin(component, suffix, value);
|
||||
const q = (suffix) => this.readParam(component, suffix);
|
||||
switch (component.type) {
|
||||
case "corexy_by_hal": w("j0-motor-pos-fb", p("alpha-fb") + p("beta-fb")); w("j1-motor-pos-fb", p("alpha-fb") - p("beta-fb")); w("alpha-cmd", 0.5 * (p("j0-motor-pos-cmd") + p("j1-motor-pos-cmd"))); w("beta-cmd", 0.5 * (p("j0-motor-pos-cmd") - p("j1-motor-pos-cmd"))); break;
|
||||
case "constant": w("out", q("value")); break;
|
||||
case "and2": w("out", p("in0") && p("in1")); break;
|
||||
case "or2": w("out", p("in0") || p("in1")); break;
|
||||
case "xor2": w("out", Boolean(p("in0") !== p("in1"))); break;
|
||||
case "not": w("out", !p("in")); break;
|
||||
case "abs": { const value = p("in"); w("out", Math.abs(value)); w("sign", value < 0); w("is-positive", value > 0.000001); w("is-negative", value < -0.000001); break; }
|
||||
case "abs_s32": { const value = p("in"); if (value === -2147483648) throw new Error("hal_s32_range"); w("out", Math.abs(value)); w("sign", value < 0); w("is-positive", value > 0); w("is-negative", value < 0); break; }
|
||||
case "lowpass": { const input = p("in"); const output = p("out"); w("out", p("load") ? input : output + (input - output) * q("gain")); break; }
|
||||
case "ddt": { const input = p("in"); w("out", input - component.memory[0]); component.memory[0] = input; break; }
|
||||
case "integ": { const input = p("in"); component.memory[0] = p("reset") ? 0 : component.memory[0] + p("gain") * input; component.memory[0] = Math.min(p("max"), Math.max(p("min"), component.memory[0])); w("out", component.memory[0]); break; }
|
||||
case "mux2": w("out", p("sel") ? p("in1") : p("in0")); break;
|
||||
case "sum2": w("out", p("in0") * q("gain0") + p("in1") * q("gain1") + q("offset")); break;
|
||||
case "mult2": w("out", p("in0") * p("in1")); break;
|
||||
case "div2": { let divisor = p("in1"); const deadband = Math.max(1e-12, q("deadband")); if (Math.abs(divisor) < deadband) divisor = divisor < 0 ? -deadband : deadband; w("out", p("in0") / divisor); break; }
|
||||
case "hypot": w("out", Math.hypot(p("in0"), p("in1"), p("in2"))); break;
|
||||
case "near": { let left = p("in1"); let right = p("in2"); if (left < 0) { left = -left; right = -right; } w("out", (q("scale") > 1 && left / q("scale") <= right && right <= left * q("scale")) || Math.abs(left - right) <= q("difference")); break; }
|
||||
case "comp": { const difference = p("in1") - p("in0"); const half = 0.5 * q("hyst"); if (difference < -half) { w("out", 0); w("equal", 0); } else if (difference > half) { w("out", 1); w("equal", 0); } else w("equal", 1); break; }
|
||||
case "invert": { const deadband = Math.max(1e-12, q("deadband")); let input = p("in"); if (Math.abs(input) < deadband) input = input < 0 ? -deadband : deadband; w("out", 1 / input); break; }
|
||||
case "edge": { const input = p("in"); const previous = q("last-in"); if (!component.flags[0]) { component.flags[0] = 1; w("out", 0); w("out-invert", 1); } else { const rise = input && !previous; const fall = !input && previous; const hit = q("both") ? rise || fall : q("in-edge") ? fall : rise; w("out", hit); w("out-invert", !hit); } this.writeParam(component, "last-in", input); break; }
|
||||
case "toggle": { const input = p("in"); let output = p("out"); const debounce = q("debounce") < 1 || q("debounce") > 10000 ? 2 : q("debounce"); if (input) { component.flags[0] = Math.min(debounce, component.flags[0] + 1); if (component.flags[0] >= debounce && !component.flags[1]) { output = output ? 0 : 1; component.flags[1] = 1; } } else { component.flags[0] = 0; component.flags[1] = 0; } w("out", output); break; }
|
||||
case "estop_latch": { const ok = p("ok-in"); const fault = p("fault-in"); const reset = p("reset"); if (!ok || fault) component.flags[0] = 0; else if (reset && !component.flags[1]) component.flags[0] = 1; component.flags[1] = reset ? 1 : 0; w("ok-out", component.flags[0]); w("fault-out", !component.flags[0]); if (component.flags[0]) component.flags[2] = component.flags[2] ? 0 : 1; w("watchdog", component.flags[2]); break; }
|
||||
default: throw new Error("hal_component_unsupported");
|
||||
}
|
||||
}
|
||||
|
||||
step(tick) {
|
||||
if (!Number.isSafeInteger(tick) || tick < this.state.tick) return this.fail("hal_tick_regression");
|
||||
const before = clone(this.state);
|
||||
try {
|
||||
for (let current = this.state.tick + 1; current <= tick; current += 1) {
|
||||
for (const link of this.state.links) this.state.pins[link.target].value = this.state.pins[link.source].value;
|
||||
for (const component of this.state.components) {
|
||||
const period = this.state.threads[component.thread].period_ticks;
|
||||
if (current % period !== 0) continue;
|
||||
if (component.failed) throw new Error("hal_function_failure");
|
||||
this.runComponent(component);
|
||||
component.calls += 1;
|
||||
}
|
||||
}
|
||||
this.state.tick = tick;
|
||||
return this.ok("HAL_STEP");
|
||||
} catch (error) {
|
||||
this.state = before;
|
||||
return this.fail(error.message);
|
||||
}
|
||||
}
|
||||
|
||||
restore(value) {
|
||||
if (!value || value.schema !== HAL_RUNTIME_SCHEMA) throw new Error("hal_restore_schema");
|
||||
const unsigned = clone(value); delete unsigned.state_hash;
|
||||
if (value.state_hash !== fnv1a64(unsigned)) throw new Error("hal_restore_hash");
|
||||
this.state = unsigned;
|
||||
return this.export();
|
||||
}
|
||||
}
|
||||
|
||||
export { SPEC as STATIC_HAL_COMPONENTS };
|
||||
export { HalRuntime as HalComponentRuntime, parseCompSource as parseHalComponent };
|
||||
Reference in New Issue
Block a user