Znaleziono 6 wyników

autor: W-Drapaki
29 gru 2018, 13:24
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Re: Przenoszenie kodu g

/**
Copyright (C) 2012-2018 by Autodesk, Inc.
All rights reserved.

$Revision: 42115 bdeb2e221ae970b5318768fc88f8111865513bf5 $
$Date: 2018-12-28 14:16:13 $

FORKID {5E39DD46-D13F-4e1b-B9F3-523506CF1212}
*/

description = "PikoCNC generic";
vendor = "Elcosimo";
vendorUrl = "http://www.pikocnc.com";
legal = "Copyright (C) 2012-2018 by Autodesk, Inc.";
certificationLevel = 2;
minimumRevision = 40783;

longDescription = "Generic milling post for PikoCNC";

extension = "nc";
setCodePage("ascii");

capabilities = CAPABILITY_MILLING;
tolerance = spatial(0.002, MM);

minimumChordLength = spatial(0.25, MM);
minimumCircularRadius = spatial(0.01, MM);
maximumCircularRadius = spatial(1000, MM);
minimumCircularSweep = toRad(0.01);
maximumCircularSweep = toRad(180);
allowHelicalMoves = true;
allowedCircularPlanes = undefined; // allow any circular motion



// user-defined properties
properties = {
writeMachine: true, // write machine
writeTools: true, // writes the tools
preloadTool: true, // preloads next tool on tool change if any
showSequenceNumbers: true, // show sequence numbers
sequenceNumberStart: 10, // first sequence number
sequenceNumberIncrement: 5, // increment for sequence numbers
separateWordsWithSpace: true // specifies that the words should be separated with a white space
};

// user-defined property definitions
propertyDefinitions = {
writeMachine: {title:"Write machine", description:"Output the machine settings in the header of the code.", group:0, type:"boolean"},
writeTools: {title:"Write tool list", description:"Output a tool list in the header of the code.", group:0, type:"boolean"},
preloadTool: {title:"Preload tool", description:"Preloads the next tool at a tool change (if any).", group:1, type:"boolean"},
showSequenceNumbers: {title:"Use sequence numbers", description:"Use sequence numbers for each block of outputted code.", group:1, type:"boolean"},
sequenceNumberStart: {title:"Start sequence number", description:"The number at which to start the sequence numbers.", group:1, type:"integer"},
sequenceNumberIncrement: {title:"Sequence number increment", description:"The amount by which the sequence number is incremented by in each block.", group:1, type:"integer"},
separateWordsWithSpace: {title:"Separate words with space", description:"Adds spaces between words if 'yes' is selected.", type:"boolean"}
};

var numberOfToolSlots = 9999;

var coolants = {
flood: {on: 8},
mist: {on: 7},
through: {},
air: {},
airThrough: {},
suction: {},
floodMist: {},
floodThrough: {},
off: 9
};

var gFormat = createFormat({prefix:"G", decimals:0});
var mFormat = createFormat({prefix:"M", decimals:0});

var xyzFormat = createFormat({decimals:(unit == MM ? 3 : 4)});
var feedFormat = createFormat({decimals:(unit == MM ? 1 : 2)});
var toolFormat = createFormat({decimals:0});
var rpmFormat = createFormat({decimals:0});
var secFormat = createFormat({decimals:3, forceDecimal:true}); // seconds - range 0.001-1000
var taperFormat = createFormat({decimals:1, scale:DEG});

var xOutput = createVariable({prefix:"X"}, xyzFormat);
var yOutput = createVariable({prefix:"Y"}, xyzFormat);
var zOutput = createVariable({onchange: function() {retracted = false;}, prefix: "Z"}, xyzFormat);
var feedOutput = createVariable({prefix: "F"}, feedFormat);
var sOutput = createVariable({prefix:"S", force:true}, rpmFormat);

// circular output
var iOutput = createReferenceVariable({prefix:"I", force:true}, xyzFormat);
var jOutput = createReferenceVariable({prefix:"J", force:true}, xyzFormat);
var kOutput = createReferenceVariable({prefix:"K", force:true}, xyzFormat);

var gMotionModal = createModal({}, gFormat); // modal group 1 // G0-G3, ...
var gPlaneModal = createModal({onchange:function () {gMotionModal.reset();}}, gFormat); // modal group 2 // G17-19
var gAbsIncModal = createModal({}, gFormat); // modal group 3 // G90-91
var gUnitModal = createModal({}, gFormat); // modal group 6 // G20-21

// collected state
var sequenceNumber;
var retracted = false; // specifies that the tool has been retracted to the safe plane

/**
Writes the specified block.
*/
function writeBlock() {
if (!formatWords(arguments)) {
return;
}
if (properties.showSequenceNumbers) {
writeWords2("N" + sequenceNumber, arguments);
sequenceNumber += properties.sequenceNumberIncrement;
} else {
writeWords(arguments);
}
}

function formatComment(text) {
return "(" + String(text).replace(/[()]/g, "") + ")";
}

/**
Output a comment.
*/
function writeComment(text) {
writeln(formatComment(text));
}

function onOpen() {
if (!properties.separateWordsWithSpace) {
setWordSeparator("");
}

sequenceNumber = properties.sequenceNumberStart;

if (programName) {
writeComment(programName);
}
if (programComment) {
writeComment(programComment);
}

// dump machine configuration
var vendor = machineConfiguration.getVendor();
var model = machineConfiguration.getModel();
var description = machineConfiguration.getDescription();

if (properties.writeMachine && (vendor || model || description)) {
writeComment(localize("Machine"));
if (vendor) {
writeComment(" " + localize("vendor") + ": " + vendor);
}
if (model) {
writeComment(" " + localize("model") + ": " + model);
}
if (description) {
writeComment(" " + localize("description") + ": " + description);
}
}

// dump tool information
if (properties.writeTools) {
var zRanges = {};
if (is3D()) {
var numberOfSections = getNumberOfSections();
for (var i = 0; i < numberOfSections; ++i) {
var section = getSection(i);
var zRange = section.getGlobalZRange();
var tool = section.getTool();
if (zRanges[tool.number]) {
zRanges[tool.number].expandToRange(zRange);
} else {
zRanges[tool.number] = zRange;
}
}
}

var tools = getToolTable();
if (tools.getNumberOfTools() > 0) {
for (var i = 0; i < tools.getNumberOfTools(); ++i) {
var tool = tools.getTool(i);
var comment = "T" + toolFormat.format(tool.number) + " " +
"D=" + xyzFormat.format(tool.diameter) + " " +
localize("CR") + "=" + xyzFormat.format(tool.cornerRadius);
if ((tool.taperAngle > 0) && (tool.taperAngle < Math.PI)) {
comment += " " + localize("TAPER") + "=" + taperFormat.format(tool.taperAngle) + localize("deg");
}
if (zRanges[tool.number]) {
comment += " - " + localize("ZMIN") + "=" + xyzFormat.format(zRanges[tool.number].getMinimum());
}
comment += " - " + getToolTypeName(tool.type);
writeComment(comment);
}
}
}

// absolute coordinates and feed per min
writeBlock(gAbsIncModal.format(90));
writeBlock(gPlaneModal.format(17));

switch (unit) {
case IN:
writeBlock(gUnitModal.format(20));
break;
case MM:
writeBlock(gUnitModal.format(21));
break;
}
}

function onComment(message) {
writeComment(message);
}

/** Force output of X, Y, and Z. */
function forceXYZ() {
xOutput.reset();
yOutput.reset();
zOutput.reset();
}

/** Force output of X, Y, Z, and F on next output. */
function forceAny() {
forceXYZ();
feedOutput.reset();
}

function onSection() {
var insertToolCall = isFirstSection() ||
currentSection.getForceToolChange && currentSection.getForceToolChange() ||
(tool.number != getPreviousSection().getTool().number);

retracted = false;
var newWorkOffset = isFirstSection() ||
(getPreviousSection().workOffset != currentSection.workOffset); // work offset changes
var newWorkPlane = isFirstSection() ||
!isSameDirection(getPreviousSection().getGlobalFinalToolAxis(), currentSection.getGlobalInitialToolAxis()) ||
(currentSection.isOptimizedForMachine() && getPreviousSection().isOptimizedForMachine() &&
Vector.diff(getPreviousSection().getFinalToolAxisABC(), currentSection.getInitialToolAxisABC()).length > 1e-4) ||
(!machineConfiguration.isMultiAxisConfiguration() && currentSection.isMultiAxis()) ||
(!getPreviousSection().isMultiAxis() && currentSection.isMultiAxis() ||
getPreviousSection().isMultiAxis() && !currentSection.isMultiAxis()); // force newWorkPlane between indexing and simultaneous operations
if (insertToolCall || newWorkOffset || newWorkPlane) {
// retract
}

if (hasParameter("operation-comment")) {
var comment = getParameter("operation-comment");
if (comment) {
writeComment(comment);
}
}

if (insertToolCall) {
setCoolant(COOLANT_OFF);

if (tool.number > numberOfToolSlots) {
warning(localize("Tool number exceeds maximum value."));
}

writeBlock("T" + toolFormat.format(tool.number), mFormat.format(6));
if (tool.comment) {
writeComment(tool.comment);
}
var showToolZMin = false;
if (showToolZMin) {
if (is3D()) {
var numberOfSections = getNumberOfSections();
var zRange = currentSection.getGlobalZRange();
var number = tool.number;
for (var i = currentSection.getId() + 1; i < numberOfSections; ++i) {
var section = getSection(i);
if (section.getTool().number != number) {
break;
}
zRange.expandToRange(section.getGlobalZRange());
}
writeComment(localize("ZMIN") + "=" + zRange.getMinimum());
}
}

if (properties.preloadTool) {
var nextTool = getNextTool(tool.number);
if (nextTool) {
writeBlock("T" + toolFormat.format(nextTool.number));
} else {
// preload first tool
var section = getSection(0);
var firstToolNumber = section.getTool().number;
if (tool.number != firstToolNumber) {
writeBlock("T" + toolFormat.format(firstToolNumber));
}
}
}
}

if (insertToolCall ||
isFirstSection() ||
(rpmFormat.areDifferent(spindleSpeed, sOutput.getCurrent())) ||
(tool.clockwise != getPreviousSection().getTool().clockwise)) {
if (spindleSpeed < 1) {
error(localize("Spindle speed out of range."));
}
if (spindleSpeed > 99999) {
warning(localize("Spindle speed exceeds maximum value."));
}
writeBlock(
sOutput.format(spindleSpeed), mFormat.format(tool.clockwise ? 3 : 4)
);
}

// wcs
// var workOffset = currentSection.workOffset;

forceXYZ();

{ // pure 3D
var remaining = currentSection.workPlane;
if (!isSameDirection(remaining.forward, new Vector(0, 0, 1))) {
error(localize("Tool orientation is not supported."));
return;
}
setRotation(remaining);
}

// set coolant after we have positioned at Z
setCoolant(tool.coolant);

forceAny();

var initialPosition = getFramePosition(currentSection.getInitialPosition());
if (!retracted && !insertToolCall) {
if (getCurrentPosition().z < initialPosition.z) {
writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));
}
}

if (insertToolCall || retracted) {
if (!machineConfiguration.isHeadConfiguration()) {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0), xOutput.format(initialPosition.x), yOutput.format(initialPosition.y)
);
writeBlock(gMotionModal.format(0), zOutput.format(initialPosition.z));
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y),
zOutput.format(initialPosition.z)
);
}
} else {
writeBlock(
gAbsIncModal.format(90),
gMotionModal.format(0),
xOutput.format(initialPosition.x),
yOutput.format(initialPosition.y)
);
}

if (insertToolCall) {
gPlaneModal.reset();
}
}

function onDwell(seconds) {
if (seconds > 99999.999) {
warning(localize("Dwelling time is out of range."));
}
seconds = clamp(0.001, seconds, 99999.999);
writeBlock(gFormat.format(4), "P" + secFormat.format(seconds));
}

function onSpindleSpeed(spindleSpeed) {
writeBlock(sOutput.format(spindleSpeed));
}

function onRadiusCompensation() {
switch (radiusCompensation) {
case RADIUS_COMPENSATION_LEFT:
case RADIUS_COMPENSATION_RIGHT:
error(localize("Radius compensation is not supported."));
break;
}
}

function onRapid(_x, _y, _z) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
if (x || y || z) {
writeBlock(gMotionModal.format(0), x, y, z);
feedOutput.reset();
}
}

function onLinear(_x, _y, _z, feed) {
var x = xOutput.format(_x);
var y = yOutput.format(_y);
var z = zOutput.format(_z);
var f = feedOutput.format(feed);
if (x || y || z) {
writeBlock(gMotionModal.format(1), x, y, z, f);
} else if (f) {
if (getNextRecord().isMotion()) { // try not to output feed without motion
feedOutput.reset(); // force feed on next line
} else {
writeBlock(gMotionModal.format(1), f);
}
}
}

function onCircular(clockwise, cx, cy, cz, x, y, z, feed) {
var start = getCurrentPosition();

if (isFullCircle()) {
if (isHelical()) {
linearize(tolerance);
return;
}
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), feedOutput.format(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), zOutput.format(z), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), yOutput.format(y), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed));
break;
default:
linearize(tolerance);
}
} else {
switch (getCircularPlane()) {
case PLANE_XY:
writeBlock(gPlaneModal.format(17), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), jOutput.format(cy - start.y, 0), feedOutput.format(feed));
break;
case PLANE_ZX:
writeBlock(gPlaneModal.format(18), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), iOutput.format(cx - start.x, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed));
break;
case PLANE_YZ:
writeBlock(gPlaneModal.format(19), gMotionModal.format(clockwise ? 2 : 3), xOutput.format(x), yOutput.format(y), zOutput.format(z), jOutput.format(cy - start.y, 0), kOutput.format(cz - start.z, 0), feedOutput.format(feed));
break;
default:
linearize(tolerance);
}
}
}

var currentCoolantMode = undefined;
var coolantOff = undefined;

function setCoolant(coolant) {
var coolantCodes = getCoolantCodes(coolant);
if (Array.isArray(coolantCodes)) {
for (var c in coolantCodes) {
writeBlock(coolantCodes[c]);
}
return undefined;
}
return coolantCodes;
}

function getCoolantCodes(coolant) {
if (!coolants) {
error(localize("Coolants have not been defined."));
}
if (!coolantOff) { // use the default coolant off command when an 'off' value is not specified for the previous coolant mode
coolantOff = coolants.off;
}

if (coolant == currentCoolantMode) {
return undefined; // coolant is already active
}

var m;
if (coolant == COOLANT_OFF) {
m = coolantOff;
coolantOff = coolants.off;
}

switch (coolant) {
case COOLANT_FLOOD:
if (!coolants.flood) {
break;
}
m = coolants.flood.on;
coolantOff = coolants.flood.off;
break;
case COOLANT_THROUGH_TOOL:
if (!coolants.throughTool) {
break;
}
m = coolants.throughTool.on;
coolantOff = coolants.throughTool.off;
break;
case COOLANT_AIR:
if (!coolants.air) {
break;
}
m = coolants.air.on;
coolantOff = coolants.air.off;
break;
case COOLANT_AIR_THROUGH_TOOL:
if (!coolants.airThroughTool) {
break;
}
m = coolants.airThroughTool.on;
coolantOff = coolants.airThroughTool.off;
break;
case COOLANT_FLOOD_MIST:
if (!coolants.floodMist) {
break;
}
m = coolants.floodMist.on;
coolantOff = coolants.floodMist.off;
break;
case COOLANT_MIST:
if (!coolants.mist) {
break;
}
m = coolants.mist.on;
coolantOff = coolants.mist.off;
break;
case COOLANT_SUCTION:
if (!coolants.suction) {
break;
}
m = coolants.suction.on;
coolantOff = coolants.suction.off;
break;
case COOLANT_FLOOD_THROUGH_TOOL:
if (!coolants.floodThroughTool) {
break;
}
m = coolants.floodThroughTool.on;
coolantOff = coolants.floodThroughTool.off;
break;
}

if (!m) {
onUnsupportedCoolant(coolant);
m = 9;
}

if (m) {
currentCoolantMode = coolant;
var multipleCoolantBlocks = new Array(); // create a formatted array to be passed into the outputted line
if (Array.isArray(m)) {
for (var i in m) {
multipleCoolantBlocks.push(mFormat.format(m));
}
} else {
multipleCoolantBlocks.push(mFormat.format(m));
}
return multipleCoolantBlocks; // return the single formatted coolant value
}
return undefined;
}

var mapCommand = {
COMMAND_STOP:0,
COMMAND_END:30,
COMMAND_SPINDLE_CLOCKWISE:3,
COMMAND_SPINDLE_COUNTERCLOCKWISE:4,
COMMAND_STOP_SPINDLE:5,
COMMAND_LOAD_TOOL:6
};

function onCommand(command) {
switch (command) {
case COMMAND_START_SPINDLE:
onCommand(tool.clockwise ? COMMAND_SPINDLE_CLOCKWISE : COMMAND_SPINDLE_COUNTERCLOCKWISE);
return;
case COMMAND_LOCK_MULTI_AXIS:
return;
case COMMAND_UNLOCK_MULTI_AXIS:
return;
case COMMAND_BREAK_CONTROL:
return;
case COMMAND_TOOL_MEASURE:
return;
}

var stringId = getCommandStringId(command);
var mcode = mapCommand[stringId];
if (mcode != undefined) {
writeBlock(mFormat.format(mcode));
} else {
onUnsupportedCommand(command);
}
}

function onSectionEnd() {
writeBlock(gPlaneModal.format(17));
forceAny();
}

/** Output block to do safe retract and/or move to home position. */
function writeRetract() {
if (arguments.length == 0) {
error(localize("No axis specified for writeRetract()."));
return;
}
var words = []; // store all retracted axes in an array
for (var i = 0; i < arguments.length; ++i) {
let instances = 0; // checks for duplicate retract calls
for (var j = 0; j < arguments.length; ++j) {
if (arguments == arguments[j]) {
++instances;
}
}
if (instances > 1) { // error if there are multiple retract calls for the same axis
error(localize("Cannot retract the same axis twice in one line"));
return;
}
switch (arguments) {
case X:
words.push("X" + xyzFormat.format(machineConfiguration.hasHomePositionX() ? machineConfiguration.getHomePositionX() : 0));
break;
case Y:
words.push("Y" + xyzFormat.format(machineConfiguration.hasHomePositionY() ? machineConfiguration.getHomePositionY() : 0));
break;
case Z:
words.push("Z" + xyzFormat.format(machineConfiguration.getRetractPlane()));
retracted = true; // specifies that the tool has been retracted to the safe plane
break;
default:
error(localize("Bad axis specified for writeRetract()."));
return;
}
}
if (words.length > 0) {
gMotionModal.reset();
if (properties.useG28) {
gAbsIncModal.reset();
writeBlock(gFormat.format(28), gAbsIncModal.format(91), words); // retract
writeBlock(gAbsIncModal.format(90));
} else {
writeBlock(gAbsIncModal.format(90), gFormat.format(53), gMotionModal.format(0), words); // retract
}
}
zOutput.reset();
}

function onClose() {
setCoolant(COOLANT_OFF);
writeBlock(mFormat.format(5)); // Spindle off
writeBlock(mFormat.format(30)); // end program
}
autor: W-Drapaki
29 gru 2018, 11:54
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Re: Przenoszenie kodu g

Nie, winny był niewłaściwy postprocesor. Po wybraniu ACU-RITE MILLPWR 3 zaczęło działać, a następnie pomógł cosimo (dzięki) i dostosował postprocesor na 100%.
autor: W-Drapaki
27 gru 2018, 20:36
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Re: Przenoszenie kodu g

Nic tam nie grzebałem, wydawało mi się że oś to oś ....
autor: W-Drapaki
27 gru 2018, 17:46
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Re: Przenoszenie kodu g

: (PGM, NAME="1551")
; T1 D=10 CR=0 - ZMIN=-20 - FLAT END MILL
: G90 G40 G94
%
G17
G71
M26
; 2D CONTOUR1
M9
M26
:T1 M6
M26
S15000 M3
H0
M8
G0 X34.059 Y40.62
Z30
Z10
G1 Z6 F30
Z3.515
X34.054 Y40.615 Z3.395
X34.04 Y40.598 Z3.276
X34.016 Y40.571 Z3.161
X33.984 Y40.534 Z3.05
X33.943 Y40.487 Z2.947
X33.894 Y40.43 Z2.852
X33.838 Y40.366 Z2.767
X33.775 Y40.294 Z2.692
X33.707 Y40.216 Z2.63
X33.635 Y40.133 Z2.58
X33.559 Y40.046 Z2.544
X33.481 Y39.957 Z2.522
X33.402 Y39.866 Z2.515
X32.745 Y39.112 F2328
G17 G3 X32.842 Y37.701 I33.499 J38.455
G2 X50 Y0.174 Z-4.985 I0 J0 K55.395
G1 Y0.087 Z-4.996
Y0 Z-5
G2 X-50 I0 J0
X50 I0 J0
X15.451 Y-47.553 Z-10 I0 J0 K25
X-15.451 Y47.553 I0 J0
X15.451 Y-47.553 I0 J0
X-40.451 Y-29.389 Z-15 I0 J0 K25
X40.451 Y29.389 I0 J0
X-40.451 Y-29.389 I0 J0
Y29.389 Z-20 I0 J0 K25
X40.451 Y-29.389 I0 J0
X-40.451 Y29.389 I0 J0
G3 X-40.672 Y30.786 I-41.26 J29.977
G1 X-41.481 Y31.374
X-41.579 Y31.445 Z-19.993
X-41.675 Y31.515 Z-19.971
X-41.768 Y31.582 Z-19.935
X-41.857 Y31.647 Z-19.885
X-41.941 Y31.708 Z-19.823
X-42.018 Y31.764 Z-19.749
X-42.087 Y31.814 Z-19.663
X-42.147 Y31.858 Z-19.568
X-42.197 Y31.894 Z-19.465
X-42.238 Y31.923 Z-19.355
X-42.267 Y31.945 Z-19.239
X-42.284 Y31.957 Z-19.121
X-42.29 Y31.962 Z-19
G0 Z30
M9
M26
G0 X0 Y0
M30
M2



Na Fusion wszystko działa, symulacja OK, a na PIKO jakieś herezje się robią....
Wiem, że jestem zielony, ale myślałem, że to się jakoś intuicyjnie da zrobić....
autor: W-Drapaki
27 gru 2018, 07:40
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Re: Przenoszenie kodu g

Przy próbie symulacji obróbki na PikoCNC wygląda tak jakby były zamienione osie, ( zrobiłem proste wycinanie kółka ze sklejki na Fusion 360 i tam wszystko OK, a po przeniesieniu na Piko wyglada tak jakby obróba odbywała się w osi Z)
autor: W-Drapaki
18 gru 2018, 12:06
Forum: PikoCNC
Temat: Przenoszenie kodu g
Odpowiedzi: 11
Odsłony: 2093

Przenoszenie kodu g

Czy można automatycznie przenieść kod g, wygenerowany na Fusion 360, na maszynę sterowaną pikocnc?

Wróć do „Przenoszenie kodu g”