halui.cc

来自「CNC 的开放码,EMC2 V2.2.8版」· CC 代码 · 共 1,793 行 · 第 1/5 页

    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->flood_is_on), "halui.flood.is-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->lube_is_on), "halui.lube.is-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->program_is_idle), "halui.program.is-idle"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->program_is_running), "halui.program.is-running"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->program_is_paused), "halui.program.is-paused"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->program_os_is_on), "halui.program.optional-stop.is-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->program_bd_is_on), "halui.program.block-delete.is-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->spindle_is_on), "halui.spindle.is-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->spindle_runs_forward), "halui.spindle.runs-forward"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->spindle_runs_backward), "halui.spindle.runs-backward"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_OUT_bit(&(halui_data->spindle_brake_is_on), "halui.spindle.brake-is-on"); 
    if (retval != HAL_SUCCESS) return retval;

    for (joint=0; joint < num_axes ; joint++) {
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_is_homed[joint]), comp_id, "halui.joint.%d.is-homed", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_is_selected[joint]), comp_id, "halui.joint.%d.is-selected", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_soft_min_limit[joint]), comp_id, "halui.joint.%d.on-soft-min-limit", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_soft_max_limit[joint]), comp_id, "halui.joint.%d.on-soft-max-limit", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_hard_min_limit[joint]), comp_id, "halui.joint.%d.on-hard-min-limit", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_hard_max_limit[joint]), comp_id, "halui.joint.%d.on-hard-max-limit", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_has_fault[joint]), comp_id, "halui.joint.%d.has-fault", joint); 
	if (retval != HAL_SUCCESS) return retval;
    }

    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_soft_min_limit[num_axes]), comp_id, "halui.joint.selected.on-soft-min-limit"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_soft_max_limit[num_axes]), comp_id, "halui.joint.selected.on-soft-limit"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_hard_min_limit[num_axes]), comp_id, "halui.joint.selected.on-hard-min-limit"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_on_hard_max_limit[num_axes]), comp_id, "halui.joint.selected.on-hard-max-limit"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_has_fault[num_axes]), comp_id, "halui.joint.selected.has-fault"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_OUT, &(halui_data->joint_is_homed[num_axes]), comp_id, "halui.joint.selected.is_homed"); 
    if (retval != HAL_SUCCESS) return retval;

    for (axis=0; axis < EMCMOT_MAX_AXIS ; axis++) {
	retval =  hal_pin_float_newf(HAL_OUT, &(halui_data->axis_pos_commanded[axis]), comp_id, "halui.axis.%d.pos-commanded", axis);
    if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_float_newf(HAL_OUT, &(halui_data->axis_pos_feedback[axis]), comp_id, "halui.axis.%d.pos-feedback", axis);
    if (retval != HAL_SUCCESS) return retval;
    }

    retval =  hal_pin_float_newf(HAL_OUT, &(halui_data->fo_value), comp_id, "halui.feed-override.value"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = hal_pin_u32_newf(HAL_OUT, &(halui_data->joint_selected), comp_id, "halui.joint.selected"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = hal_pin_u32_newf(HAL_OUT, &(halui_data->tool_number), comp_id, "halui.tool.number"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_float_newf(HAL_OUT, &(halui_data->tool_length_offset), comp_id, "halui.tool.length_offset"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_float_newf(HAL_OUT, &(halui_data->so_value), comp_id, "halui.spindle-override.value"); 
    if (retval != HAL_SUCCESS) return retval;

    /* STEP 3b: export the in-pin(s) */

    retval = halui_export_pin_IN_bit(&(halui_data->machine_on), "halui.machine.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->machine_off), "halui.machine.off"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->estop_activate), "halui.estop.activate"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->estop_reset), "halui.estop.reset"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mode_manual), "halui.mode.manual"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mode_auto), "halui.mode.auto"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mode_mdi), "halui.mode.mdi"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mode_teleop), "halui.mode.teleop"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mode_joint), "halui.mode.joint"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mist_on), "halui.mist.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->mist_off), "halui.mist.off"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->flood_on), "halui.flood.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->flood_off), "halui.flood.off"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->lube_on), "halui.lube.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->lube_off), "halui.lube.off"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_run), "halui.program.run"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_pause), "halui.program.pause"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_resume), "halui.program.resume"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_step), "halui.program.step"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_stop), "halui.program.stop"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_os_on), "halui.program.optional-stop.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_os_off), "halui.program.optional-stop.off"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_bd_on), "halui.program.block-delete.on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->program_bd_off), "halui.program.block-delete.off"); 
    if (retval != HAL_SUCCESS) return retval;

    retval = halui_export_pin_IN_bit(&(halui_data->spindle_start), "halui.spindle.start");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_stop), "halui.spindle.stop");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_forward), "halui.spindle.forward");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_reverse), "halui.spindle.reverse");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_increase), "halui.spindle.increase");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_decrease), "halui.spindle.decrease");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_brake_on), "halui.spindle.brake-on"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->spindle_brake_off), "halui.spindle.brake-off"); 
    if (retval != HAL_SUCCESS) return retval;

    retval = halui_export_pin_IN_s32(&(halui_data->fo_counts), "halui.feed-override.counts");
    if (retval != HAL_SUCCESS) return retval;
    *halui_data->fo_counts = 0;
    retval = halui_export_pin_IN_float(&(halui_data->fo_scale), "halui.feed-override.scale");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->fo_increase), "halui.feed-override.increase");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->fo_decrease), "halui.feed-override.decrease");
    if (retval != HAL_SUCCESS) return retval;

    retval = halui_export_pin_IN_s32(&(halui_data->so_counts), "halui.spindle-override.counts");
    if (retval != HAL_SUCCESS) return retval;
    *halui_data->so_counts = 0;
    retval = halui_export_pin_IN_float(&(halui_data->so_scale), "halui.spindle-override.scale");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->so_increase), "halui.spindle-override.increase");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_bit(&(halui_data->so_decrease), "halui.spindle-override.decrease");
    if (retval != HAL_SUCCESS) return retval;

    retval = halui_export_pin_IN_bit(&(halui_data->abort), "halui.abort"); 
    if (retval != HAL_SUCCESS) return retval;

    for (joint=0; joint < num_axes ; joint++) {
	retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->joint_home[joint]), comp_id, "halui.joint.%d.home", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->joint_nr_select[joint]), comp_id, "halui.joint.%d.select", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->jog_plus[joint]), comp_id, "halui.jog.%d.plus", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->jog_minus[joint]), comp_id, "halui.jog.%d.minus", joint); 
	if (retval != HAL_SUCCESS) return retval;
	retval =  hal_pin_float_newf(HAL_IN, &(halui_data->jog_analog[joint]), comp_id, "halui.jog.%d.analog", joint); 
	if (retval != HAL_SUCCESS) return retval;
    }

    retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->joint_home[num_axes]), comp_id, "halui.joint.selected.home"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->jog_plus[num_axes]), comp_id, "halui.jog.selected.plus"); 
    if (retval != HAL_SUCCESS) return retval;
    retval =  hal_pin_bit_newf(HAL_IN, &(halui_data->jog_minus[num_axes]), comp_id, "halui.jog.selected.minus"); 
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_float(&(halui_data->jog_speed), "halui.jog-speed");
    if (retval != HAL_SUCCESS) return retval;
    retval = halui_export_pin_IN_float(&(halui_data->jog_deadband), "halui.jog-deadband");
    if (retval != HAL_SUCCESS) return retval;


    for (int n=0; n<num_mdi_commands; n++) {
        retval = hal_pin_bit_newf(HAL_IN, &(halui_data->mdi_commands[n]), comp_id, "halui.mdi-command-%02d", n);
        if (retval != HAL_SUCCESS) return retval;
    }

    hal_ready(comp_id);
    return 0;
}

static int sendMachineOn()
{
    EMC_TASK_SET_STATE state_msg;

    state_msg.state = EMC_TASK_STATE_ON;
    state_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(state_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendMachineOff()
{
    EMC_TASK_SET_STATE state_msg;

    state_msg.state = EMC_TASK_STATE_OFF;
    state_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(state_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendEstop()
{
    EMC_TASK_SET_STATE state_msg;

    state_msg.state = EMC_TASK_STATE_ESTOP;
    state_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(state_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendEstopReset()
{
    EMC_TASK_SET_STATE state_msg;

    state_msg.state = EMC_TASK_STATE_ESTOP_RESET;
    state_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(state_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendManual()
{
    EMC_TASK_SET_MODE mode_msg;

    mode_msg.mode = EMC_TASK_MODE_MANUAL;
    mode_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(mode_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendAuto()
{
    EMC_TASK_SET_MODE mode_msg;

    mode_msg.mode = EMC_TASK_MODE_AUTO;
    mode_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(mode_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendMdi()
{
    EMC_TASK_SET_MODE mode_msg;

    mode_msg.mode = EMC_TASK_MODE_MDI;
    mode_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(mode_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

int sendMdiCmd(char *mdi)
{
    EMC_TASK_PLAN_EXECUTE emc_task_plan_execute_msg;

    if (emcStatus->task.mode != EMC_TASK_MODE_MDI) {
	halui_old_mode = emcStatus->task.mode;
	sendMdi();
    }
    strcpy(emc_task_plan_execute_msg.command, mdi);
    emc_task_plan_execute_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_task_plan_execute_msg);
    halui_sent_mdi = 1;
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendMdiCommand(int n)
{
    int r1,r2;
    halui_old_mode = emcStatus->task.mode;
    r1 = sendMdi();
    r2 = sendMdiCmd(mdi_commands[n]);
    return r1 || r2;
}


static int sendTeleop()
{
    EMC_TRAJ_SET_TELEOP_ENABLE emc_set_teleop_enable_msg;

    emc_set_teleop_enable_msg.enable = 1;
    emc_set_teleop_enable_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_set_teleop_enable_msg);
    return emcCommandWaitDone(emcCommandSerialNumber);
}

static int sendJoint()
{
    EMC_TRAJ_SET_TELEOP_ENABLE emc_set_teleop_enable_msg;

    emc_set_teleop_enable_msg.enable = 0;
    emc_set_teleop_enable_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_set_teleop_enable_msg);
    return emcCommandWaitDone(emcCommandSerialNumber);
}

static int sendMistOn()
{
    EMC_COOLANT_MIST_ON emc_coolant_mist_on_msg;

    emc_coolant_mist_on_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_coolant_mist_on_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendMistOff()
{
    EMC_COOLANT_MIST_OFF emc_coolant_mist_off_msg;

    emc_coolant_mist_off_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_coolant_mist_off_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendFloodOn()
{
    EMC_COOLANT_FLOOD_ON emc_coolant_flood_on_msg;

    emc_coolant_flood_on_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_coolant_flood_on_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendFloodOff()
{
    EMC_COOLANT_FLOOD_OFF emc_coolant_flood_off_msg;

    emc_coolant_flood_off_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_coolant_flood_off_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendLubeOn()
{
    EMC_LUBE_ON emc_lube_on_msg;

    emc_lube_on_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_lube_on_msg);
    return emcCommandWaitReceived(emcCommandSerialNumber);
}

static int sendLubeOff()
{