js::Value GCodeLibrary::speedCB(const js::Arguments &args) {
// Return spindle info if no arguments were given
if (!args.getCount()) {
js::Value array = js::Value::createArray(3);
spin_mode_t mode;
double max;
array.set(0, ctx.machine.getSpeed(&mode, &max));
array.set(1, mode);
array.set(2, max);
return array;
}
// Otherwise set spindle
spin_mode_t mode = REVOLUTIONS_PER_MINUTE;
double max = 0;
if (args.has("surface")) {
mode = CONSTANT_SURFACE_SPEED;
if (args.has("max")) max = args["max"].toNumber();
}
ctx.machine.setSpeed(args["rate"].toNumber(), mode, max);
return ctx.machine.getSpeed();
}
js::Value GCodeLibrary::feedCB(const js::Arguments &args) {
// Return feed info if no arguments were given
if (!args.getCount()) {
js::Value array = js::Value::createArray(2);
feed_mode_t mode;
array.set(0, ctx.machine.getFeed(&mode));
array.set(1, mode);
return array;
}
// Otherwise set feed
feed_mode_t mode = MM_PER_MINUTE;
if (args.has("mode")) {
mode = (feed_mode_t)args["mode"].toUint32();
switch (mode) {
case INVERSE_TIME: case MM_PER_MINUTE: case MM_PER_REVOLUTION: break;
default: THROW("Feed mode must be FEED_INVERSE_TIME, FEED_UNITS_PER_MIN or "
"FEED_UNITS_PER_REV");
}
}
ctx.machine.setFeed(args["rate"].toNumber(), mode);
return ctx.machine.getFeed();
}
void GCodeLibrary::parseAxes(const js::Arguments &args, Axes &axes,
bool incremental) {
for (const char *axis ="xyzabcuvw"; *axis; axis++) {
string name = string(1, *axis);
if (args.has(name)) axes.set(*axis, args.getNumber(name) +
(incremental ? axes.get(*axis) : 0));
}
}
js::Value GCodeLibrary::toolSetCB(const js::Arguments &args) {
SmartPointer<OpenSCAM::Tool> tool = ctx.tools->get(args["number"].toUint32());
uint32_t units;
double scale = 1;
if (args.has("units")) units = args["units"].toUint32();
else units = unitAdapter.getUnits();
if (units == MachineUnitAdapter::METRIC)
tool->setUnits(OpenSCAM::ToolUnits::UNITS_MM);
else {
tool->setUnits(OpenSCAM::ToolUnits::UNITS_INCH);
scale = 25.4;
}
if (args.has("shape"))
tool->setShape((OpenSCAM::ToolShape::enum_t)args["shape"].toUint32());
tool->setLength(scale * args.getNumber("length"));
tool->setDiameter(scale * args.getNumber("diameter"));
tool->setSnubDiameter(scale * args.getNumber("snub"));
tool->setFrontAngle(args.getNumber("front_angle"));
tool->setBackAngle(args.getNumber("back_angle"));
tool->setOrientation(args.getNumber("orientation"));
return js::Value();
}
js::Value GCodeLibrary::cutCB(const js::Arguments &args) {
Axes axes = ctx.machine.getPosition();
parseAxes(args, axes, args.getBoolean("incremental"));
ctx.machine.move(axes);
return js::Value();
}
MatrixModule::axes_t MatrixModule::parseMatrix(const js::Arguments &args) {
if (!args.has("matrix")) return XYZ;
axes_t matrix = (axes_t)args["matrix"].toUint32();
if (AXES_COUNT <= matrix) THROWS("Invalid matrix number " << matrix);
return matrix;
}
js::Value GCodeLibrary::probeCB(const js::Arguments &args) {
bool toward = args.getBoolean("toward");
bool error = args.getBoolean("error");
uint32_t index = args.getUint32("index");
int port = args.getInt32("port");
bool invert = args.getInt32("invert");
if (port == -1) port = ctx.machine.findPort(PROBE, index);
if (port != -1)
ctx.machine.input(port, toward ^ invert ? STOP_WHEN_HIGH : STOP_WHEN_LOW,
error);
Axes axes = ctx.machine.getPosition();
parseAxes(args, axes);
ctx.machine.move(axes);
return js::Value();
}
js::Value GCodeLibrary::toolCB(const js::Arguments &args) {
// Return tool number if no arguments were given
if (!args.getCount()) return ctx.machine.getTool();
uint32_t number = args["number"].toUint32();
ctx.tools->get(number); // Make sure it exists
ctx.machine.setTool(number);
return ctx.machine.getTool();
}
js::Value GCodeLibrary::gcodeCB(const js::Arguments &args) {
string path =
SystemUtilities::makeRelative(ctx.currentPath(), args.getString("path"));
ctx.pushPath(path);
SmartFunctor<TPLContext> popPath(&ctx, &TPLContext::popPath);
Options options;
OpenSCAM::Controller controller(ctx.machine);
OpenSCAM::Interpreter(controller).read(path);
return js::Value();
}
js::Value GCodeLibrary::arcCB(const js::Arguments &args) {
Vector3D
offset(args.getNumber("x"), args.getNumber("y"), args.getNumber("z"));
double angle = args.getNumber("angle");
plane_t plane = args.has("plane") ? (plane_t)args.getUint32("plane") : XY;
ctx.machine.arc(offset, angle, plane);
return js::Value();
}
js::Value GCodeLibrary::unitsCB(const js::Arguments &args) {
MachineUnitAdapter::units_t units = unitAdapter.getUnits();
if (args.has("type"))
switch (args["type"].toUint32()) {
case MachineUnitAdapter::IMPERIAL:
unitAdapter.setUnits(MachineUnitAdapter::IMPERIAL);
break;
case MachineUnitAdapter::METRIC:
unitAdapter.setUnits(MachineUnitAdapter::METRIC);
break;
default: THROWS("Units type must be one of IMPERIAL or METRIC");
}
else return js::Value(units);
return js::Value();
}
js::Value DXFLibrary::openCB(const js::Arguments &args) {
string path =
SystemUtilities::absolute(ctx.getCurrentPath(), args.getString("path"));
DXFReader reader;
reader.read(path);
const DXFReader::layers_t &layers = reader.getLayers();
js::Value v8Layers = layersTmpl.create();
DXFReader::layers_t::const_iterator it;
for (it = layers.begin(); it != layers.end(); it++) {
const DXFReader::layer_t &layer = it->second;
js::Value v8Layer = js::Value::createArray(layer.size());
for (unsigned j = 0; j < layer.size(); j++) {
const DXFEntity &entity = *layer[j];
js::Value obj = entityTmpl.create();
switch (entity.getType()) {
case DXFEntity::DXF_POINT: {
const DXFPoint &point = dynamic_cast<const DXFPoint &>(entity);
obj.set("x", point.x());
obj.set("y", point.y());
obj.set("z", point.z());
break;
}
case DXFEntity::DXF_LINE: {
const DXFLine &line = dynamic_cast<const DXFLine &>(entity);
js::Value start = entityTmpl.create();
start.set("x", line.getStart().x());
start.set("y", line.getStart().y());
start.set("z", line.getStart().z());
obj.set("start", start);
js::Value end = entityTmpl.create();
end.set("x", line.getEnd().x());
end.set("y", line.getEnd().y());
end.set("z", line.getEnd().z());
obj.set("end", end);
break;
}
case DXFEntity::DXF_ARC: {
const DXFArc &arc = dynamic_cast<const DXFArc &>(entity);
js::Value center = entityTmpl.create();
center.set("x", arc.getCenter().x());
center.set("y", arc.getCenter().y());
center.set("z", arc.getCenter().z());
obj.set("center", center);
obj.set("radius", arc.getRadius());
obj.set("startAngle", arc.getStartAngle());
obj.set("endAngle", arc.getEndAngle());
obj.set("clockwise", arc.getClockwise());
break;
}
case DXFEntity::DXF_POLYLINE: {
const DXFPolyLine &polyLine = dynamic_cast<const DXFPolyLine &>(entity);
const vector<Vector3D> &vertices = polyLine.getVertices();
js::Value v8Vertices = js::Value::createArray(vertices.size());
for (unsigned k = 0; k < vertices.size(); k++) {
js::Value pt = entityTmpl.create();
pt.set("x", vertices[k].x());
pt.set("y", vertices[k].y());
pt.set("z", vertices[k].z());
pt.set("type", DXFEntity::DXF_POINT);
v8Vertices.set(k, pt);
}
obj.set("vertices", v8Vertices);
break;
}
case DXFEntity::DXF_SPLINE: {
const DXFSpline &spline = dynamic_cast<const DXFSpline &>(entity);
obj.set("degree", spline.getDegree());
// Control points
const vector<Vector3D> &ctrlPts = spline.getControlPoints();
js::Value v8CtrlPts = js::Value::createArray(ctrlPts.size());
for (unsigned k = 0; k < ctrlPts.size(); k++) {
js::Value pt = entityTmpl.create();
pt.set("x", ctrlPts[k].x());
pt.set("y", ctrlPts[k].y());
pt.set("z", ctrlPts[k].z());
pt.set("type", DXFEntity::DXF_POINT);
v8CtrlPts.set(k, pt);
}
obj.set("ctrlPts", v8CtrlPts);
// Knots
const vector<double> &knots = spline.getKnots();
js::Value v8Knots = js::Value::createArray(knots.size());
for (unsigned k = 0; k < knots.size(); k++)
v8Knots.set(k, knots[k]);
obj.set("knots", v8Knots);
break;
}
default: THROWS("Invalid DXF entity type " << entity.getType());
}
obj.set("type", entity.getType());
v8Layer.set(j, obj);
}
v8Layers.set(it->first, v8Layer);
}
return v8Layers;
}
js::Value MatrixModule::rotateCB(const js::Arguments &args) {
matrix.rotate(args.getNumber("angle"), args.getNumber("x"),
args.getNumber("y"), args.getNumber("z"), parseMatrix(args));
return js::Value();
}
js::Value MatrixModule::scaleCB(const js::Arguments &args) {
matrix.scale(args.getNumber("x"), args.getNumber("y"), args.getNumber("z"),
parseMatrix(args));
return js::Value();
}
