wangdequan/linuxcncWebWASM
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement AXIS parity UI and execution baseline

Browse Source
This commit is contained in:
wangdequan
2026-08-23 07:28:37 +08:00
parent 1325504544
commit 06f96f85e5
463 changed files with 84893 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
wasm-core/include/sim_device_io.h Normal file
View File

@@ -0,0 +1,120 @@
#ifndef LINUXCNC_WEB_WASM_SIM_DEVICE_IO_H
#define LINUXCNC_WEB_WASM_SIM_DEVICE_IO_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define SIM_DEVICE_MAX_ENCODERS 8U
#define SIM_DEVICE_MAX_ACKS 64U
enum sim_device_result {
SIM_DEVICE_OK = 0,
SIM_DEVICE_ERR_ARGUMENT = -1000,
SIM_DEVICE_ERR_RANGE = -1001,
SIM_DEVICE_ERR_NONFINITE = -1002,
SIM_DEVICE_ERR_CAPACITY = -1003,
SIM_DEVICE_ERR_STATE = -1004,
SIM_DEVICE_ERR_INTERLOCK = -1005,
SIM_DEVICE_ERR_DUPLICATE = -1006,
SIM_DEVICE_ERR_MISSING = -1007,
SIM_DEVICE_ERR_LATE_ACK = -1008,
SIM_DEVICE_ERR_TIMEOUT = -1009,
};
enum sim_device_ack_status {
SIM_DEVICE_ACK_UNUSED = 0,
SIM_DEVICE_ACK_PENDING = 1,
SIM_DEVICE_ACK_ACKED = 2,
SIM_DEVICE_ACK_TIMED_OUT = 3,
SIM_DEVICE_ACK_ABORTED = 4,
};
typedef struct sim_device_encoder_state {
uint32_t registered;
double speed_rps;
uint32_t ppr;
double scale;
int32_t raw_count;
int32_t count;
double position;
double velocity;
uint32_t phase_a;
uint32_t phase_b;
uint32_t phase_z;
uint32_t index_enable;
uint32_t index_pulse;
uint32_t tick;
} sim_device_encoder_state;
typedef struct sim_device_coolant_state {
uint32_t mist_requested;
uint32_t flood_requested;
uint32_t lube_requested;
uint32_t mist;
uint32_t flood;
uint32_t lube;
uint32_t fault;
} sim_device_coolant_state;
typedef struct sim_device_safety_state {
uint32_t door_open;
uint32_t input_ok;
uint32_t estop;
uint32_t fault;
uint32_t interlock_ok;
uint32_t latched_fault;
uint32_t recovery_epoch;
} sim_device_safety_state;
typedef struct sim_device_ack_entry {
uint32_t used;
uint32_t operation_id;
uint32_t issued_tick;
uint32_t deadline_tick;
uint32_t status;
} sim_device_ack_entry;
typedef struct sim_device_io_state {
uint32_t tick;
uint32_t encoder_count;
sim_device_encoder_state encoders[SIM_DEVICE_MAX_ENCODERS];
sim_device_coolant_state coolant;
sim_device_safety_state safety;
sim_device_ack_entry acks[SIM_DEVICE_MAX_ACKS];
int32_t last_error;
} sim_device_io_state;
typedef struct sim_device_io {
sim_device_io_state state;
double cycle_time;
double phase_accumulator[SIM_DEVICE_MAX_ENCODERS];
} sim_device_io;
int sim_device_init(sim_device_io *device, uint32_t encoder_count, double cycle_time);
int sim_device_reset(sim_device_io *device);
int sim_device_encoder_set_speed(sim_device_io *device, uint32_t channel, double speed_rps);
int sim_device_encoder_set_config(sim_device_io *device, uint32_t channel, uint32_t ppr, double scale);
int sim_device_encoder_set_index_enable(sim_device_io *device, uint32_t channel, uint32_t enable);
int sim_device_coolant_command(sim_device_io *device, uint32_t mist, uint32_t flood, uint32_t lube);
int sim_device_coolant_set_fault(sim_device_io *device, uint32_t fault);
int sim_device_door_set(sim_device_io *device, uint32_t open);
int sim_device_interlock_set(sim_device_io *device, uint32_t input_ok);
int sim_device_interlock_reset(sim_device_io *device);
int sim_device_estop_set(sim_device_io *device, uint32_t estop);
int sim_device_step(sim_device_io *device, uint32_t ticks);
int sim_device_ack_issue(sim_device_io *device, uint32_t operation_id, uint32_t timeout_ticks);
int sim_device_ack_ack(sim_device_io *device, uint32_t operation_id);
int sim_device_ack_abort(sim_device_io *device, uint32_t operation_id);
int sim_device_ack_step(sim_device_io *device, uint32_t ticks);
int sim_device_read_state(const sim_device_io *device, sim_device_io_state *state);
uint64_t sim_device_state_hash(const sim_device_io *device);
uint32_t sim_device_canonical(const sim_device_io *device, char *output, uint32_t capacity);
#ifdef __cplusplus
}
#endif
#endif

8
wasm-core/include/sim_hal.h
View File

@@ -11,6 +11,8 @@ extern "C" {
#define SIM_HAL_PIN_CAPACITY 256U
#define SIM_HAL_THREAD_CAPACITY 16U
#define SIM_HAL_FUNCTION_CAPACITY 64U
#define SIM_HAL_COMPONENT_CAPACITY 64U
#define SIM_HAL_PARAM_CAPACITY 256U
enum sim_hal_result {
SIM_HAL_OK = 0,
@@ -49,6 +51,12 @@ int32_t sim_hal_get_pin(const char *name, sim_hal_value *out);
int32_t sim_hal_connect(const char *source, const char *target);
int32_t sim_hal_register_thread(const char *name, uint32_t period_ticks);
int32_t sim_hal_register_function(const char *thread, const char *name);
/* Register a statically linked .comp component instance on a HAL thread. */
int32_t sim_hal_register_component(const char *instance, const char *type, const char *thread);
int32_t sim_hal_set_param(const char *name, sim_hal_value value);
int32_t sim_hal_get_param(const char *name, sim_hal_value *out);
uint32_t sim_hal_component_count(void);
uint32_t sim_hal_param_count(void);
/* Register the static LinuxCNC corexy_by_hal component and its servo pins. */
int32_t sim_hal_register_corexy_by_hal(const char *component, const char *thread);
/* Execute one deterministic CoreXY command/feedback transform immediately. */

10
wasm-core/include/sim_interpreter.h
View File

@@ -16,6 +16,8 @@ enum sim_interpreter_result {
SIM_INTERP_ERR_UNKNOWN_CODE = -504,
SIM_INTERP_ERR_STATE = -505,
SIM_INTERP_ERR_BUFFER = -506,
SIM_INTERP_ERR_PARAMETER = -507,
SIM_INTERP_ERR_EXPRESSION = -508,
};
enum sim_interpreter_units {
@@ -51,6 +53,8 @@ typedef struct sim_interpreter_state {
} sim_interpreter_state;
#define SIM_INTERPRETER_CANONICAL_CAPACITY 512u
#define SIM_INTERPRETER_PARAMETER_MIN 1u
#define SIM_INTERPRETER_PARAMETER_MAX 5399u
typedef struct sim_interpreter {
sim_interpreter_state state;
@@ -62,10 +66,16 @@ typedef struct sim_interpreter {
int sim_interpreter_init(sim_interpreter *interpreter);
int sim_interpreter_reset(sim_interpreter *interpreter);
int sim_interpreter_execute(sim_interpreter *interpreter, const char *block, uint32_t length);
uint32_t sim_interpreter_size(void);
int sim_interpreter_read_state(const sim_interpreter *interpreter, sim_interpreter_state *state);
uint32_t sim_interpreter_canonical(const sim_interpreter *interpreter, char *output, uint32_t capacity);
uint64_t sim_interpreter_state_hash(const sim_interpreter *interpreter);
uint64_t sim_interpreter_block_hash(const sim_interpreter *interpreter);
uint64_t sim_interpreter_modal_hash(const sim_interpreter *interpreter);
uint32_t sim_interpreter_error_column(const sim_interpreter *interpreter);
int32_t sim_interpreter_error_code(const sim_interpreter *interpreter);
int sim_interpreter_parameter_set(sim_interpreter *interpreter, uint32_t index, double value);
int sim_interpreter_parameter_get(const sim_interpreter *interpreter, uint32_t index, double *value);
#ifdef __cplusplus
}

11
wasm-core/include/sim_motion_queue.h
View File

@@ -19,6 +19,11 @@ enum sim_motion_result {
SIM_MOTION_ERR_BUFFER = -607,
};
enum sim_motion_profile {
SIM_MOTION_PROFILE_BLEND = 0,
SIM_MOTION_PROFILE_EXACT_STOP = 1,
};
#define SIM_MOTION_QUEUE_CAPACITY 64u
typedef struct sim_motion_command {
@@ -54,9 +59,15 @@ int sim_motion_init(sim_motion_queue *queue, double cycle_time, double velocity_
int sim_motion_reset(sim_motion_queue *queue);
int sim_motion_enqueue(sim_motion_queue *queue, const sim_motion_command *command, uint32_t *id_out);
int sim_motion_step(sim_motion_queue *queue);
int sim_motion_set_profile(sim_motion_queue *queue, int profile);
int sim_motion_set_lookahead(sim_motion_queue *queue, uint32_t depth);
int sim_motion_set_dynamics(sim_motion_queue *queue, double acceleration_limit, double jerk_limit);
int sim_motion_set_paused(sim_motion_queue *queue, uint32_t paused);
int sim_motion_peek(const sim_motion_queue *queue, uint32_t offset, sim_motion_command *command);
int sim_motion_read_state(const sim_motion_queue *queue, sim_motion_state *state);
uint32_t sim_motion_queue_depth(const sim_motion_queue *queue);
uint64_t sim_motion_state_hash(const sim_motion_queue *queue);
uint64_t sim_motion_plan_hash(const sim_motion_queue *queue);
uint32_t sim_motion_canonical(const sim_motion_queue *queue, char *output, uint32_t capacity);
#ifdef __cplusplus

58
wasm-core/include/sim_scheduler.h Normal file
View File

@@ -0,0 +1,58 @@
#ifndef LINUXCNC_WEB_WASM_SIM_SCHEDULER_H
#define LINUXCNC_WEB_WASM_SIM_SCHEDULER_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define SIM_SCHEDULER_SCHEMA_VERSION 1U
#define SIM_SCHEDULER_PHASE_COUNT 8U
#define SIM_SCHEDULER_DEFAULT_BUDGET 1000000U
#define SIM_SCHEDULER_CANONICAL_CAPACITY 512U
enum sim_scheduler_result {
SIM_SCHEDULER_OK = 0,
SIM_SCHEDULER_ERR_ARGUMENT = -1100,
SIM_SCHEDULER_ERR_RANGE = -1101,
SIM_SCHEDULER_ERR_BUDGET = -1102,
SIM_SCHEDULER_ERR_OVERFLOW = -1103,
SIM_SCHEDULER_ERR_BUFFER = -1104,
};
enum sim_scheduler_phase {
SIM_SCHEDULER_RECONCILE = 0,
SIM_SCHEDULER_TASK = 1,
SIM_SCHEDULER_TP = 2,
SIM_SCHEDULER_KINEMATICS = 3,
SIM_SCHEDULER_MOTION = 4,
SIM_SCHEDULER_HAL_IO = 5,
SIM_SCHEDULER_CALLBACKS = 6,
SIM_SCHEDULER_PUBLISH = 7,
};
typedef struct sim_scheduler {
uint32_t tick;
uint32_t budget;
uint32_t last_cycles;
uint32_t phase_trace[SIM_SCHEDULER_PHASE_COUNT];
} sim_scheduler;
uint32_t sim_scheduler_size(void);
int32_t sim_scheduler_init(sim_scheduler *scheduler, uint32_t budget);
int32_t sim_scheduler_reset(sim_scheduler *scheduler);
int32_t sim_scheduler_step(sim_scheduler *scheduler, uint32_t cycles);
int32_t sim_scheduler_restore(sim_scheduler *scheduler, uint32_t tick, uint32_t budget,
uint32_t last_cycles, const uint32_t *phase_trace,
uint32_t phase_count);
int32_t sim_scheduler_read(const sim_scheduler *scheduler, sim_scheduler *out);
uint32_t sim_scheduler_tick(const sim_scheduler *scheduler);
uint64_t sim_scheduler_state_hash(const sim_scheduler *scheduler);
uint32_t sim_scheduler_canonical(const sim_scheduler *scheduler, char *output, uint32_t capacity);
#ifdef __cplusplus
}
#endif
#endif

96
wasm-core/include/sim_task.h Normal file
View File

@@ -0,0 +1,96 @@
#ifndef LINUXCNC_WEB_WASM_SIM_TASK_H
#define LINUXCNC_WEB_WASM_SIM_TASK_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#define SIM_TASK_SCHEMA_VERSION 1U
#define SIM_TASK_CONTEXT_CAPACITY 128U
#define SIM_TASK_SESSION_CAPACITY 128U
#define SIM_TASK_CANONICAL_CAPACITY 512U
#define SIM_TASK_NO_LINE UINT32_MAX
enum sim_task_result {
SIM_TASK_OK = 0,
SIM_TASK_ERR_ARGUMENT = -1000,
SIM_TASK_ERR_STATE = -1001,
SIM_TASK_ERR_TRANSITION = -1002,
SIM_TASK_ERR_SEQUENCE = -1003,
SIM_TASK_ERR_TICK = -1004,
SIM_TASK_ERR_RANGE = -1005,
SIM_TASK_ERR_NONFINITE = -1006,
SIM_TASK_ERR_BUFFER = -1007,
SIM_TASK_ERR_DESTROYED = -1008,
};
enum sim_task_state_value {
SIM_TASK_NEW = 0,
SIM_TASK_READY = 1,
SIM_TASK_RUNNING = 2,
SIM_TASK_PAUSED = 3,
SIM_TASK_ESTOP = 4,
SIM_TASK_FAULT = 5,
SIM_TASK_STOPPED = 6,
SIM_TASK_DESTROYED = 7,
};
enum sim_task_mode_value {
SIM_TASK_MODE_MANUAL = 0,
SIM_TASK_MODE_MDI = 1,
SIM_TASK_MODE_AUTO = 2,
};
enum sim_task_program_value {
SIM_TASK_PROGRAM_IDLE = 0,
SIM_TASK_PROGRAM_LOADED = 1,
SIM_TASK_PROGRAM_RUNNING = 2,
SIM_TASK_PROGRAM_PAUSED = 3,
SIM_TASK_PROGRAM_COMPLETED = 4,
SIM_TASK_PROGRAM_ABORTED = 5,
SIM_TASK_PROGRAM_FAULT = 6,
};
typedef struct sim_task_state {
char context_id[SIM_TASK_CONTEXT_CAPACITY];
char session_id[SIM_TASK_SESSION_CAPACITY];
uint32_t state;
uint32_t mode;
uint32_t program_status;
uint32_t seq;
uint32_t simulation_tick;
uint32_t current_line;
int32_t last_error;
} sim_task_state;
typedef struct sim_task {
sim_task_state state;
} sim_task;
uint32_t sim_task_size(void);
int32_t sim_task_init(sim_task *task, const char *context_id, const char *session_id);
int32_t sim_task_reset(sim_task *task);
int32_t sim_task_attach(sim_task *task);
int32_t sim_task_set_command(sim_task *task, uint32_t seq, uint32_t simulation_tick);
int32_t sim_task_set_tick(sim_task *task, uint32_t simulation_tick);
int32_t sim_task_set_mode(sim_task *task, uint32_t mode);
int32_t sim_task_set_program(sim_task *task, uint32_t program_status, uint32_t current_line);
int32_t sim_task_transition(sim_task *task, uint32_t state);
int32_t sim_task_fault(sim_task *task, int32_t error_code);
int32_t sim_task_estop(sim_task *task, int32_t error_code);
int32_t sim_task_recover(sim_task *task);
int32_t sim_task_restore(sim_task *task, uint32_t state, uint32_t mode,
uint32_t program_status, uint32_t seq,
uint32_t simulation_tick, uint32_t current_line,
int32_t error_code);
int32_t sim_task_read_state(const sim_task *task, sim_task_state *out);
uint32_t sim_task_canonical(const sim_task *task, char *output, uint32_t capacity);
uint64_t sim_task_state_hash(const sim_task *task);
#ifdef __cplusplus
}
#endif
#endif