emcsh.cc

Source code for an Numeric Cmputer

    emcCommandBuffer->write(emc_tool_set_offset_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisSetGains(int axis, double p, double i, double d,
			    double ff0, double ff1, double ff2,
			    double bias, double maxError, double deadband)
{
    EMC_AXIS_SET_GAINS emc_axis_set_gains_msg;

    emc_axis_set_gains_msg.axis = axis;
    emc_axis_set_gains_msg.p = p;
    emc_axis_set_gains_msg.i = i;
    emc_axis_set_gains_msg.d = d;
    emc_axis_set_gains_msg.ff0 = ff0;
    emc_axis_set_gains_msg.ff1 = ff1;
    emc_axis_set_gains_msg.ff2 = ff2;
    emc_axis_set_gains_msg.bias = bias;
    emc_axis_set_gains_msg.maxError = maxError;
    emc_axis_set_gains_msg.deadband = deadband;
    emc_axis_set_gains_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_axis_set_gains_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisSetBacklash(int axis, double backlash)
{
    EMC_AXIS_SET_BACKLASH emc_axis_set_backlash_msg;

    emc_axis_set_backlash_msg.axis = axis;
    emc_axis_set_backlash_msg.backlash = backlash;
    emc_axis_set_backlash_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_axis_set_backlash_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisSetOutput(int axis, double output)
{
    EMC_AXIS_SET_OUTPUT emc_axis_set_output_msg;

    emc_axis_set_output_msg.axis = axis;
    emc_axis_set_output_msg.output = output;
    emc_axis_set_output_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_axis_set_output_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisEnable(int axis, int val)
{
    EMC_AXIS_ENABLE emc_axis_enable_msg;
    EMC_AXIS_DISABLE emc_axis_disable_msg;

    if (val) {
	emc_axis_enable_msg.axis = axis;
	emc_axis_enable_msg.serial_number = ++emcCommandSerialNumber;
	emcCommandBuffer->write(emc_axis_enable_msg);
    } else {
	emc_axis_disable_msg.axis = axis;
	emc_axis_disable_msg.serial_number = ++emcCommandSerialNumber;
	emcCommandBuffer->write(emc_axis_disable_msg);
    }
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisLoadComp(int axis, const char *file)
{
    EMC_AXIS_LOAD_COMP emc_axis_load_comp_msg;

    strcpy(emc_axis_load_comp_msg.file, file);
    emc_axis_load_comp_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_axis_load_comp_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendAxisAlter(int axis, double alter)
{
    EMC_AXIS_ALTER emc_axis_alter_msg;

    emc_axis_alter_msg.alter = alter;
    emc_axis_alter_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_axis_alter_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendSetTeleopEnable(int enable)
{
    EMC_TRAJ_SET_TELEOP_ENABLE emc_set_teleop_enable_msg;

    emc_set_teleop_enable_msg.enable = enable;
    emc_set_teleop_enable_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_set_teleop_enable_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendSetProbeIndex(int index)
{
    EMC_TRAJ_SET_PROBE_INDEX emc_set_probe_index_msg;

    emc_set_probe_index_msg.index = index;
    emc_set_probe_index_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_set_probe_index_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendSetProbePolarity(int polarity)
{
    EMC_TRAJ_SET_PROBE_POLARITY emc_set_probe_polarity_msg;

    emc_set_probe_polarity_msg.serial_number = ++emcCommandSerialNumber;
    emc_set_probe_polarity_msg.polarity = polarity;
    emcCommandBuffer->write(emc_set_probe_polarity_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendClearProbeTrippedFlag()
{
    EMC_TRAJ_CLEAR_PROBE_TRIPPED_FLAG emc_clear_probe_tripped_flag_msg;

    emc_clear_probe_tripped_flag_msg.serial_number =
	++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_clear_probe_tripped_flag_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

static int sendProbe(double x, double y, double z)
{
    EMC_TRAJ_PROBE emc_probe_msg;

    emc_probe_msg.pos.tran.x = x;
    emc_probe_msg.pos.tran.y = y;
    emc_probe_msg.pos.tran.z = z;

    emc_probe_msg.serial_number = ++emcCommandSerialNumber;
    emcCommandBuffer->write(emc_probe_msg);
    if (emcWaitType == EMC_WAIT_RECEIVED) {
	return emcCommandWaitReceived(emcCommandSerialNumber);
    } else if (emcWaitType == EMC_WAIT_DONE) {
	return emcCommandWaitDone(emcCommandSerialNumber);
    }

    return 0;
}

/* EMC command functions */

static int emc_plat(ClientData clientdata,
		    Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{
    if (objc == 1) {
	Tcl_SetResult(interp, "Linux", TCL_VOLATILE);
	return TCL_OK;
    }

    Tcl_SetResult(interp, "emc_plat: need no args", TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_ini(ClientData clientdata,
		   Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{
    Inifile inifile;
    const char *inistring;
    const char *varstr, *secstr, *defaultstr;
    defaultstr = 0;

    if (objc != 3 && objc != 4) {
	Tcl_SetResult(interp, "emc_ini: need 'var' and 'section'",
		      TCL_VOLATILE);
	return TCL_ERROR;
    }
    // open it
    if (inifile.open(EMC_INIFILE) == false) {
	return TCL_OK;
    }

    varstr = Tcl_GetStringFromObj(objv[1], 0);
    secstr = Tcl_GetStringFromObj(objv[2], 0);

    if (objc == 4) {
	defaultstr = Tcl_GetStringFromObj(objv[3], 0);
    }

    if (NULL == (inistring = inifile.find(varstr, secstr))) {
	if (defaultstr != 0) {
	    Tcl_SetResult(interp, (char *) defaultstr, TCL_VOLATILE);
	}
	return TCL_OK;
    }

    Tcl_SetResult(interp, (char *) inistring, TCL_VOLATILE);

    // close it
    inifile.close();

    return TCL_OK;
}

static int emc_debug(ClientData clientdata,
		     Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{
    Tcl_Obj *debug_obj;
    int debug;

    if (emcUpdateType == EMC_UPDATE_AUTO) {
	updateStatus();
    }

    if (objc == 1) {
	// no arg-- return current value
	debug_obj = Tcl_NewIntObj(emcStatus->debug);
	Tcl_SetObjResult(interp, debug_obj);
	return TCL_OK;
    }

    if (objc == 2) {
	if (0 != Tcl_GetIntFromObj(0, objv[1], &debug)) {
	    Tcl_SetResult(interp, "emc_debug: need debug level as integer",
			  TCL_VOLATILE);
	    return TCL_ERROR;
	}
	sendDebug(debug);
	EMC_DEBUG = debug;
	return TCL_OK;
    }
    // wrong number of args
    Tcl_SetResult(interp, "emc_debug: need zero or one arg", TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_set_wait(ClientData clientdata,
			Tcl_Interp * interp, int objc,
			Tcl_Obj * CONST objv[])
{
    char *objstr;

    if (objc == 1) {
	switch (emcWaitType) {
	case EMC_WAIT_NONE:
	    Tcl_SetResult(interp, "none", TCL_VOLATILE);
	    break;
	case EMC_WAIT_RECEIVED:
	    Tcl_SetResult(interp, "received", TCL_VOLATILE);
	    break;
	case EMC_WAIT_DONE:
	    Tcl_SetResult(interp, "done", TCL_VOLATILE);
	    break;
	default:
	    Tcl_SetResult(interp, "(invalid)", TCL_VOLATILE);
	    break;
	}
	return TCL_OK;
    }

    if (objc == 2) {
	objstr = Tcl_GetStringFromObj(objv[1], 0);
	if (!strcmp(objstr, "none")) {
	    emcWaitType = EMC_WAIT_NONE;
	    return TCL_OK;
	}
	if (!strcmp(objstr, "received")) {
	    emcWaitType = EMC_WAIT_RECEIVED;
	    return TCL_OK;
	}
	if (!strcmp(objstr, "done")) {
	    emcWaitType = EMC_WAIT_DONE;
	    return TCL_OK;
	}
    }

    Tcl_SetResult(interp,
		  "emc_set_wait: need 'none', 'received', 'done', or no args",
		  TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_wait(ClientData clientdata,
		    Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{
    char *objstr;

    if (objc == 2) {
	objstr = Tcl_GetStringFromObj(objv[1], 0);
	if (!strcmp(objstr, "received")) {
	    if (0 != emcCommandWaitReceived(emcCommandSerialNumber)) {
		Tcl_SetResult(interp, "timeout", TCL_VOLATILE);
	    }
	    return TCL_OK;
	}
	if (!strcmp(objstr, "done")) {
	    if (0 != emcCommandWaitDone(emcCommandSerialNumber)) {
		Tcl_SetResult(interp, "timeout", TCL_VOLATILE);
	    }
	    return TCL_OK;
	}
    }

    Tcl_SetResult(interp, "emc_wait: need 'received' or 'done'",
		  TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_set_timeout(ClientData clientdata,
			   Tcl_Interp * interp, int objc,
			   Tcl_Obj * CONST objv[])
{
    double timeout;
    Tcl_Obj *timeout_obj;

    if (objc == 1) {
	timeout_obj = Tcl_NewDoubleObj(emcTimeout);
	Tcl_SetObjResult(interp, timeout_obj);
	return TCL_OK;
    }

    if (objc == 2) {
	if (TCL_OK == Tcl_GetDoubleFromObj(0, objv[1], &timeout)) {
	    emcTimeout = timeout;
	    return TCL_OK;
	}
    }

    Tcl_SetResult(interp, "emc_set_timeout: need time as real number",
		  TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_update(ClientData clientdata,
		      Tcl_Interp * interp, int objc,
		      Tcl_Obj * CONST objv[])
{
    char *objstr;

    if (objc == 1) {
	// no arg-- return status
	updateStatus();
	return TCL_OK;
    }

    if (objc == 2) {
	objstr = Tcl_GetStringFromObj(objv[1], 0);
	if (!strcmp(objstr, "none")) {
	    emcUpdateType = EMC_UPDATE_NONE;
	    return TCL_OK;
	}
	if (!strcmp(objstr, "auto")) {
	    emcUpdateType = EMC_UPDATE_AUTO;
	    return TCL_OK;
	}
    }

    return TCL_OK;
}

static int emc_time(ClientData clientdata,
		    Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{
    if (objc == 1) {
#if defined(LINUX_KERNEL_2_2)
	/*! \todo FIXME-- Linux 2.2 has gettimeofday() bug, so return 0 */
	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(0.0));
#else
	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(etime()));
#endif
	return TCL_OK;
    }

    Tcl_SetResult(interp, "emc_time: needs no arguments", TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_error(ClientData clientdata,
		     Tcl_Interp * interp, int objc, Tcl_Obj * CONST objv[])
{

    if (objc == 1) {
	// get any new error, it's saved in global error_string[]
	if (0 != updateError()) {
	    Tcl_SetResult(interp, "emc_error: bad status from EMC",
			  TCL_VOLATILE);
	    return TCL_ERROR;
	}
	// put error on result list
	if (error_string[0] == 0) {
	    Tcl_SetResult(interp, "ok", TCL_VOLATILE);
	} else {
	    Tcl_SetResult(interp, error_string, TCL_VOLATILE);
	    error_string[0] = 0;
	}
	return TCL_OK;
    }

    Tcl_SetResult(interp, "emc_error: need no args", TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_operator_text(ClientData clientdata,
			     Tcl_Interp * interp, int objc,
			     Tcl_Obj * CONST objv[])
{

    if (objc == 1) {
	// get any new string, it's saved in global operator_text_string[]
	if (0 != updateError()) {
	    Tcl_SetResult(interp, "emc_operator_text: bad status from EMC",
			  TCL_VOLATILE);
	    return TCL_ERROR;
	}
	// put error on result list
	if (operator_text_string[0] == 0) {
	    Tcl_SetResult(interp, "ok", TCL_VOLATILE);
	    operator_text_string[0] = 0;
	} else {
	    Tcl_SetResult(interp, operator_text_string, TCL_VOLATILE);
	}
	return TCL_OK;
    }

    Tcl_SetResult(interp, "emc_operator_text: need no args", TCL_VOLATILE);
    return TCL_ERROR;
}

static int emc_operator_display(ClientData clientdata,
				Tcl_Interp * interp, int objc,
				Tcl_Obj * CONST objv[])
{

    if (objc == 1) {
	// get any new string, it's saved in global operator_display_string[]
	if (0 != updateError()) {
	    Tcl_SetResult(interp,