533 lines
No EOL
13 KiB
JavaScript
533 lines
No EOL
13 KiB
JavaScript
$(function() {
|
|
gcParser = function() {
|
|
self = this;
|
|
|
|
self.toolOffsets = [{x: 0, y: 0}];
|
|
|
|
self.parse = function(gcode, blockDelimiter, blockCallback ) {
|
|
var argChar, numSlice;
|
|
|
|
var x, y, z, pi, pj, pp = 0;
|
|
var clockwise = false;
|
|
var laser = 0;
|
|
var prevX = 0, prevY = 0, prevZ = -1;
|
|
var f, lastF = 4000;
|
|
var extrude = false, extrudeRelative = false, retract = 0;
|
|
var positionRelative = false;
|
|
|
|
var dcExtrude = false;
|
|
var assumeNonDC = false;
|
|
|
|
var tool = 0;
|
|
var prev_extrude = [{a: 0, b: 0, c: 0, e: 0, abs: 0}];
|
|
var prev_retract = [0];
|
|
var offset = self.toolOffsets[0];
|
|
|
|
var gcode_lines = gcode.split(/\n/);
|
|
|
|
var model = [];
|
|
for (var i = 0; i < gcode_lines.length; i++) {
|
|
x = undefined;
|
|
y = undefined;
|
|
z = undefined;
|
|
pi = undefined;
|
|
pj = undefined;
|
|
pp = undefined;
|
|
clockwise = false;
|
|
retract = 0;
|
|
|
|
extrude = false;
|
|
var line = gcode_lines[i].split(/[\(;]/)[0];
|
|
|
|
var addToModel = false;
|
|
var convertAndAddToModel = false;
|
|
var move = false;
|
|
|
|
|
|
if (/^(?:G0|G00|G1|G01)\s+/i.test(line)) {
|
|
var args = line.split(/\s+/);
|
|
|
|
for (var j = 0; j < args.length; j++) {
|
|
switch (argChar = args[j].charAt(0).toLowerCase()) {
|
|
case 'x':
|
|
if (positionRelative) {
|
|
x = prevX + Number(args[j].slice(1)) + offset.x;
|
|
} else {
|
|
x = Number(args[j].slice(1)) + offset.x;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'y':
|
|
if (positionRelative) {
|
|
y = prevY + Number(args[j].slice(1)) + offset.y;
|
|
} else {
|
|
y = Number(args[j].slice(1)) + offset.y;
|
|
// console.log('#', gcode_lines[i-2], gcode_lines[i-1], line, y);
|
|
}
|
|
|
|
break;
|
|
|
|
case 'z':
|
|
if (positionRelative) {
|
|
z = prevZ + Number(args[j].slice(1));
|
|
} else {
|
|
z = Number(args[j].slice(1));
|
|
}
|
|
|
|
break;
|
|
|
|
case 'e':
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
assumeNonDC = true;
|
|
numSlice = Number(args[j].slice(1));
|
|
|
|
if (!extrudeRelative) {
|
|
// absolute extrusion positioning
|
|
prev_extrude[tool]["abs"] = numSlice - prev_extrude[tool][argChar];
|
|
prev_extrude[tool][argChar] = numSlice;
|
|
} else {
|
|
prev_extrude[tool]["abs"] = numSlice;
|
|
prev_extrude[tool][argChar] += numSlice;
|
|
}
|
|
|
|
extrude = prev_extrude[tool]["abs"] > 0;
|
|
if (prev_extrude[tool]["abs"] < 0) {
|
|
prev_retract[tool] = -1;
|
|
retract = -1;
|
|
} else if (prev_extrude[tool]["abs"] === 0) {
|
|
retract = 0;
|
|
} else if (prev_extrude[tool]["abs"] > 0 && prev_retract[tool] < 0) {
|
|
prev_retract[tool] = 0;
|
|
retract = 1;
|
|
} else {
|
|
retract = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
numSlice = parseFloat(args[j].slice(1));
|
|
lastF = numSlice;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dcExtrude && !assumeNonDC) {
|
|
extrude = true;
|
|
prev_extrude[tool]["abs"] = Math.sqrt((prevX - x) * (prevX - x) + (prevY - y) * (prevY - y));
|
|
}
|
|
|
|
if (typeof (x) !== 'undefined' || typeof (y) !== 'undefined' || typeof (z) !== 'undefined' || retract !== 0) {
|
|
addToModel = true;
|
|
move = true;
|
|
}
|
|
} else if (/^(?:G2|G02|G3|G03)\s+/i.test(line)) {
|
|
var units = "G21"; // mm
|
|
var args = line.split(/\s+/);
|
|
var lastPos = {x: prevX, y: prevY, z: prevZ};
|
|
|
|
clockwise = /^(?:G2|G02)/i.test(args[0]);
|
|
for (var j = 0; j < args.length; j++) {
|
|
switch (argChar = args[j].charAt(0).toLowerCase()) {
|
|
case 'x':
|
|
if (positionRelative) {
|
|
x = prevX + Number(args[j].slice(1)) + offset.x;
|
|
} else {
|
|
x = Number(args[j].slice(1)) + offset.x;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'y':
|
|
if (positionRelative) {
|
|
y = prevY + Number(args[j].slice(1)) + offset.y;
|
|
} else {
|
|
y = Number(args[j].slice(1)) + offset.y;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'z':
|
|
if (positionRelative) {
|
|
z = prevZ + Number(args[j].slice(1));
|
|
} else {
|
|
z = Number(args[j].slice(1));
|
|
}
|
|
|
|
break;
|
|
|
|
case 'i':
|
|
pi = Number(args[j].slice(1)) + offset.x;
|
|
|
|
break;
|
|
|
|
case 'j':
|
|
pj = Number(args[j].slice(1)) + offset.y;
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
pp = Number(args[j].slice(1));
|
|
|
|
break;
|
|
|
|
case 'e':
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
assumeNonDC = true;
|
|
numSlice = Number(args[j].slice(1));
|
|
|
|
if (!extrudeRelative) {
|
|
// absolute extrusion positioning
|
|
prev_extrude[tool]["abs"] = numSlice - prev_extrude[tool][argChar];
|
|
prev_extrude[tool][argChar] = numSlice;
|
|
} else {
|
|
prev_extrude[tool]["abs"] = numSlice;
|
|
prev_extrude[tool][argChar] += numSlice;
|
|
}
|
|
|
|
extrude = prev_extrude[tool]["abs"] > 0;
|
|
if (prev_extrude[tool]["abs"] < 0) {
|
|
prev_retract[tool] = -1;
|
|
retract = -1;
|
|
} else if (prev_extrude[tool]["abs"] === 0) {
|
|
retract = 0;
|
|
} else if (prev_extrude[tool]["abs"] > 0 && prev_retract[tool] < 0) {
|
|
prev_retract[tool] = 0;
|
|
retract = 1;
|
|
} else {
|
|
retract = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
numSlice = parseFloat(args[j].slice(1));
|
|
lastF = numSlice;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dcExtrude && !assumeNonDC) {
|
|
extrude = true;
|
|
prev_extrude[tool]["abs"] = Math.sqrt((prevX - x) * (prevX - x) + (prevY - y) * (prevY - y));
|
|
}
|
|
|
|
if (typeof (x) !== 'undefined' || typeof (y) !== 'undefined' || typeof (z) !== 'undefined'
|
|
|| typeof (pi) !== 'undefined' || typeof (pj) !== 'undefined' || typeof (pp) !== 'undefined' || retract !== 0) {
|
|
|
|
convertAndAddToModel = true;
|
|
move = true;
|
|
}
|
|
// } else if (/^(?:M82)/i.test(line)) {
|
|
// extrudeRelative = false;
|
|
} else if (/^(?:M3|M03)/i.test(line)) {
|
|
var args = line.split(/\s+/);
|
|
for (var j = 0; j < args.length; j++) {
|
|
switch (argChar = args[j].charAt(0).toLowerCase()) {
|
|
case 's':
|
|
laser = Number(args[j].slice(1));
|
|
break;
|
|
}
|
|
}
|
|
} else if (/^(?:M5|M05)/i.test(line)) {
|
|
laser = 0;
|
|
} else if (/^(?:G91)/i.test(line)) {
|
|
positionRelative = true;
|
|
extrudeRelative = true;
|
|
} else if (/^(?:G90)/i.test(line)) {
|
|
positionRelative = false;
|
|
extrudeRelative = false;
|
|
// } else if (/^(?:M83)/i.test(line)) {
|
|
// extrudeRelative = true;
|
|
// } else if (/^(?:M101)/i.test(line)) {
|
|
// dcExtrude = true;
|
|
// } else if (/^(?:M103)/i.test(line)) {
|
|
// dcExtrude = false;
|
|
} else if (/^(?:G92)/i.test(line)) {
|
|
var args = line.split(/\s/);
|
|
|
|
for (var j = 0; j < args.length; j++) {
|
|
if (!args[j])
|
|
continue;
|
|
|
|
if (args.length === 1) {
|
|
// G92 without coordinates => reset all axes to 0
|
|
x = 0;
|
|
y = 0;
|
|
z = 0;
|
|
prev_extrude[tool]["e"] = 0;
|
|
prev_extrude[tool]["a"] = 0;
|
|
prev_extrude[tool]["b"] = 0;
|
|
prev_extrude[tool]["c"] = 0;
|
|
} else {
|
|
switch (argChar = args[j].charAt(0).toLowerCase()) {
|
|
case 'x':
|
|
x = Number(args[j].slice(1)) + offset.x;
|
|
break;
|
|
|
|
case 'y':
|
|
y = Number(args[j].slice(1)) + offset.y;
|
|
break;
|
|
|
|
case 'z':
|
|
z = Number(args[j].slice(1));
|
|
prevZ = z;
|
|
break;
|
|
|
|
case 'e':
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
numSlice = Number(args[j].slice(1));
|
|
if (!extrudeRelative)
|
|
prev_extrude[tool][argChar] = 0;
|
|
else {
|
|
prev_extrude[tool][argChar] = numSlice;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeof (x) !== 'undefined' || typeof (y) !== 'undefined' || typeof (z) !== 'undefined') {
|
|
addToModel = true;
|
|
move = false;
|
|
}
|
|
|
|
} else if (/^(?:G28|$H)/i.test(line)) {
|
|
var args = line.split(/\s/);
|
|
|
|
if (args.length === 1) {
|
|
// G28 with no arguments => home all axis
|
|
x = 0;
|
|
y = 0;
|
|
z = 0;
|
|
} else {
|
|
for (j = 0; j < args.length; j++) {
|
|
switch (argChar = args[j].charAt(0).toLowerCase()) {
|
|
case 'x':
|
|
x = 0;
|
|
break;
|
|
case 'y':
|
|
y = 0;
|
|
break;
|
|
case 'z':
|
|
z = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeof (x) !== 'undefined' || typeof (y) !== 'undefined' || typeof (z) !== 'undefined' || retract !== 0) {
|
|
addToModel = true;
|
|
move = true;
|
|
}
|
|
} else if (/^(?:T\d+)/i.test(line)) {
|
|
tool = Number(line.split(/\s/)[0].slice(1));
|
|
if (!prev_extrude[tool])
|
|
prev_extrude[tool] = {a: 0, b: 0, c: 0, e: 0, abs: 0};
|
|
if (!prev_retract[tool])
|
|
prev_retract[tool] = 0;
|
|
|
|
offset = self.toolOffsets[tool] || {x: 0, y: 0};
|
|
}
|
|
|
|
// ensure z is set.
|
|
if (typeof (z) === 'undefined') {
|
|
if (typeof (prevZ) !== 'undefined') {
|
|
z = prevZ;
|
|
} else {
|
|
z = 0;
|
|
}
|
|
}
|
|
|
|
if (addToModel && !isNaN(x) && !isNaN(y)) { // TODO: hack. unclear why y sometimes is undefined.
|
|
model.push({
|
|
x: x,
|
|
y: y,
|
|
z: z,
|
|
extrude: extrude,
|
|
laser: laser,
|
|
retract: retract,
|
|
noMove: !move,
|
|
extrusion: (extrude || retract) && prev_extrude[tool]["abs"] ? prev_extrude[tool]["abs"] : 0,
|
|
prevX: prevX,
|
|
prevY: prevY,
|
|
prevZ: prevZ,
|
|
speed: lastF,
|
|
gcodeLine: i,
|
|
percentage: i / gcode_lines.length,
|
|
tool: tool
|
|
});
|
|
}
|
|
if (convertAndAddToModel) {
|
|
var parts = self._convertG2G3(clockwise, x, y, z, pi, pj, pp, lastPos, units);
|
|
var lastPart = parts[0];
|
|
for (var l = 1; l < parts.length; l++) {
|
|
var part = parts[l];
|
|
|
|
model.push({
|
|
x: part[0],
|
|
y: part[1],
|
|
z: part[2],
|
|
extrude: extrude,
|
|
laser: laser,
|
|
retract: retract,
|
|
noMove: !move,
|
|
extrusion: (extrude || retract) && prev_extrude[tool]["abs"] ? prev_extrude[tool]["abs"] : 0,
|
|
prevX: lastPart[0],
|
|
prevY: lastPart[1],
|
|
prevZ: lastPart[2],
|
|
speed: lastF,
|
|
gcodeLine: i,
|
|
percentage: i / gcode_lines.length,
|
|
tool: tool
|
|
});
|
|
|
|
lastPart = part;
|
|
}
|
|
}
|
|
|
|
if (move) {
|
|
if (typeof (x) !== 'undefined')
|
|
prevX = x;
|
|
if (typeof (y) !== 'undefined')
|
|
prevY = y;
|
|
}
|
|
|
|
if (typeof (blockCallback) === 'function' && typeof (blockDelimiter) !== 'undefined' && blockDelimiter.test(line)) {
|
|
blockCallback(model);
|
|
model = model.slice(-1); // keep the last element as start of the next block
|
|
}
|
|
}
|
|
|
|
prevZ = z;
|
|
if (typeof (blockCallback) === 'function' && model.length > 0) {
|
|
blockCallback(model);
|
|
}
|
|
};
|
|
|
|
self._convertG2G3 = function(clockwise, x, y, z, i, j, p, lastPos, units) {
|
|
if (typeof (x) === 'undefined')
|
|
x = lastPos.x;
|
|
if (typeof (y) === 'undefined')
|
|
y = lastPos.y;
|
|
if (typeof (z) === 'undefined')
|
|
z = lastPos.z;
|
|
if (typeof (i) === 'undefined')
|
|
i = 0.0;
|
|
if (typeof (j) === 'undefined')
|
|
j = 0.0;
|
|
if (typeof (p) === 'undefined')
|
|
p = 1.0;
|
|
|
|
var curveSection = 1.0; // mm
|
|
if (units === "G20") { // inches
|
|
curveSection = 1.0 / 25.4;
|
|
}
|
|
|
|
// angle variables.
|
|
var angleA;
|
|
var angleB;
|
|
var angle;
|
|
|
|
// delta variables.
|
|
var aX;
|
|
var aY;
|
|
var bX;
|
|
var bY;
|
|
|
|
|
|
// center of rotation
|
|
var cX = lastPos.x + i;
|
|
var cY = lastPos.y + j;
|
|
|
|
aX = lastPos.x - cX;
|
|
aY = lastPos.y - cY;
|
|
bX = x - cX;
|
|
bY = y - cY;
|
|
|
|
// Clockwise
|
|
if (clockwise) {
|
|
angleA = Math.atan2(bY, bX);
|
|
angleB = Math.atan2(aY, aX);
|
|
} else {
|
|
angleA = Math.atan2(aY, aX);
|
|
angleB = Math.atan2(bY, bX);
|
|
}
|
|
|
|
// Make sure angleB is always greater than angleA
|
|
// and if not add 2PI so that it is (this also takes
|
|
// care of the special case of angleA == angleB,
|
|
// ie we want a complete circle)
|
|
if (angleB <= angleA) {
|
|
angleB += 2 * Math.PI * p;
|
|
}
|
|
angle = angleB - angleA;
|
|
|
|
// calculate a couple useful things.
|
|
var radius = Math.sqrt(aX * aX + aY * aY);
|
|
var length = radius * angle;
|
|
|
|
// for doing the actual move.
|
|
var steps; // TODO accuracy setting
|
|
var s;
|
|
|
|
// Maximum of either 2.4 times the angle in radians
|
|
// or the length of the curve divided by the curve section constant
|
|
steps = Math.ceil(Math.max(angle * 2.4, length / curveSection));
|
|
|
|
|
|
var fta;
|
|
if (!clockwise) {
|
|
fta = angleA + angle;
|
|
} else {
|
|
fta = angleA;
|
|
}
|
|
|
|
// THis if arc is correct
|
|
// TODO move this into the validator
|
|
var r2 = Math.sqrt(bX * bX + bY * bY);
|
|
var percentage;
|
|
if (r2 > radius) {
|
|
percentage = Math.abs(radius / r2) * 100.0;
|
|
} else {
|
|
percentage = Math.abs(r2 / radius) * 100.0;
|
|
}
|
|
|
|
if (percentage < 99.7) {
|
|
var sb = "";
|
|
sb += "Radius to end of arc differs from radius to start:\n";
|
|
sb += "r1=" + radius + "\n";
|
|
sb += "r2=" + r2 + "\n";
|
|
console.error("gcode_parser.js convertG2G3", sb);
|
|
}
|
|
|
|
// this is the real line calculation.
|
|
var parts = [];
|
|
var arcStartZ = lastPos.z;
|
|
for (s = 1; s <= steps; s++) {
|
|
var step;
|
|
if (!clockwise)
|
|
step = s;
|
|
else
|
|
step = steps - s;
|
|
|
|
var ta = (angleA + angle * (step / steps));
|
|
|
|
parts.push([cX + radius * Math.cos(ta), cY + radius * Math.sin(ta), lastPos.z + (z - arcStartZ) * s / steps]);
|
|
|
|
}
|
|
|
|
return parts;
|
|
};
|
|
|
|
};
|
|
}); |