public void AddCommentToNullLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
gcb.AppendComment("addingComment");
}
public void AddLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
GCodeLine l = new GCodeLine(100, LineType.Comment);
l.Comment = "testComment";
gcb.AddLine(l);
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("testComment", mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.Comment, mockGCA.Lines[0].Type);
Assert.AreEqual(0, mockGCA.Lines[0].LineNumber);
GCodeLine l2 = new GCodeLine(100, LineType.GCode);
l2.Comment = "testComment2";
l2.Code = 10;
GCodeParam p = GCodeParam.Double(2.5, "X");
l2.Parameters = new GCodeParam[1] {
p
};
gcb.AddLine(l2);
Assert.IsTrue(mockGCA.Lines.Count == 2);
Assert.AreEqual("testComment2", mockGCA.Lines[1].Comment);
Assert.AreEqual(10, mockGCA.Lines[1].Code);
Assert.AreEqual(LineType.GCode, mockGCA.Lines[1].Type);
Assert.AreEqual(1, mockGCA.Lines[1].LineNumber);
Assert.AreEqual(p, mockGCA.Lines[1].Parameters[0]);
}
public void BeginGLineAndAppend()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
gcb.BeginGLine(1, "comment");
Assert.IsTrue(mockGCA.Lines.Count == 0);
gcb.AppendComment("addingComment");
gcb.AppendI("intTest", 3);
gcb.AppendF("floatTest", 2.3);
gcb.AppendS("stringTest", "stringTest");
gcb.AppendL("labelTest");
gcb.EndLine();
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("addingComment", mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.GCode, mockGCA.Lines[0].Type);
Assert.AreEqual(0, mockGCA.Lines[0].LineNumber);
var par = mockGCA.Lines[0].Parameters;
Assert.AreEqual(4, par.Length);
Assert.AreEqual(GCodeParamTypes.IntegerValue, par[0].Type);
Assert.AreEqual(3, par[0].IntegerValue);
Assert.AreEqual("intTest", par[0].Identifier);
Assert.AreEqual(GCodeParamTypes.DoubleValue, par[1].Type);
Assert.AreEqual(2.3, par[1].DoubleValue);
Assert.AreEqual("floatTest", par[1].Identifier);
Assert.AreEqual(GCodeParamTypes.TextValue, par[2].Type);
Assert.AreEqual("stringTest", par[2].TextValue);
Assert.AreEqual("stringTest", par[2].Identifier);
Assert.AreEqual(GCodeParamTypes.NoValue, par[3].Type);
Assert.AreEqual("labelTest", par[3].Identifier);
}
static void Main(string[] args)
{
var gcode_accumulator = new GCodeFileAccumulator();
var builder = new GCodeBuilder(gcode_accumulator);
MakerbotSettings settings = new MakerbotSettings();
SingleMaterialFFFCompiler compiler = new SingleMaterialFFFCompiler(
builder, settings, MakerbotAssembler.Factory);
settings.ExtruderTempC = 200;
compiler.Begin();
//generate_stacked_polygon(compiler, settings);
//generate_stacked_wavy_circle(compiler, settings);
//generate_square(compiler, settings);
//generate_vertical(compiler, settings);
generate_vertical_wave(compiler, settings);
compiler.End();
GCodeFile gcode = gcode_accumulator.File;
using (StreamWriter w = new StreamWriter(OUT_PATH + "generated.gcode")) {
StandardGCodeWriter writer = new StandardGCodeWriter();
writer.WriteFile(gcode, w);
}
}
public BaseDepositionAssembler MakePrintrbotAssembler(
GCodeBuilder builder, SingleMaterialFFFSettings settings)
{
var asm = new RepRapAssembler(builder, settings);
asm.HeaderCustomizerF = HeaderCustomF;
return(asm);
}
protected void HeaderCustomF(RepRapAssembler.HeaderState state, GCodeBuilder Builder)
{
if (state == RepRapAssembler.HeaderState.BeforePrime)
{
if (EnableAutoBedLevel)
{
Builder.BeginGLine(29, "auto-level bed");
}
}
}
public BaseDepositionAssembler MakePrusaAssembler(
GCodeBuilder builder, SingleMaterialFFFSettings settings)
{
var asm = new RepRapAssembler(builder, settings);
asm.HomeSequenceF = this.HomeSequence;
asm.HeaderCustomizerF = HeaderCustomF;
asm.TravelGCode = 1;
return(asm);
}
public void AddCommentLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
gcb.AddCommentLine("comment");
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("comment", mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.Comment, mockGCA.Lines[0].Type);
Assert.AreEqual(1, mockGCA.Lines[0].LineNumber);
}
public void AddExplicitLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
gcb.AddExplicitLine("explicit");
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("explicit", mockGCA.Lines[0].OriginalString);
Assert.IsNull(mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.UnknownString, mockGCA.Lines[0].Type);
Assert.AreEqual(1, mockGCA.Lines[0].LineNumber);
}
protected virtual void HomeSequence(GCodeBuilder builder)
{
if (Machine.HasAutoBedLeveling && Machine.EnableAutoBedLeveling)
{
builder.BeginGLine(28).AppendL("W").AppendComment("home all without bed level");
builder.BeginGLine(80, "auto-level bed");
}
else
{
// standard home sequenece
builder.BeginGLine(28, "home x/y").AppendI("X", 0).AppendI("Y", 0);
builder.BeginGLine(28, "home z").AppendI("Z", 0);
}
}
public void BeginAndEndMLine()
{
MockGCodeAccumulator mockGCA = new MockGCodeAccumulator();
GCodeBuilder gcb = new GCodeBuilder(mockGCA);
gcb.BeginMLine(1, "comment");
Assert.IsTrue(mockGCA.Lines.Count == 0);
gcb.EndLine();
Assert.IsTrue(mockGCA.Lines.Count == 1);
Assert.AreEqual("comment", mockGCA.Lines[0].Comment);
Assert.AreEqual(LineType.MCode, mockGCA.Lines[0].Type);
Assert.AreEqual(0, mockGCA.Lines[0].LineNumber);
}
protected virtual void HeaderCustomF(RepRapAssembler.HeaderState state, GCodeBuilder Builder)
{
if (state == RepRapAssembler.HeaderState.AfterComments)
{
if (ModelEnum == Prusa.Models.i3_MK3)
{
Builder.BeginMLine(201)
.AppendI("X", 1000).AppendI("Y", 1000).AppendI("Z", 200).AppendI("E", 5000)
.AppendComment("Set maximum accelleration in mm/sec^2");
Builder.BeginMLine(203)
.AppendI("X", 200).AppendI("Y", 200).AppendI("Z", 12).AppendI("E", 120)
.AppendComment("Set maximum feedrates in mm/sec");
Builder.BeginMLine(204)
.AppendI("S", 1250).AppendI("T", 1250)
.AppendComment("Set acceleration for moves (S) and retract (T)");
Builder.BeginMLine(205)
.AppendF("X", 10).AppendF("Y", 10).AppendF("Z", 0.4).AppendF("E", 2.5)
.AppendComment("Set jerk limits in mm/sec");
Builder.BeginMLine(205)
.AppendI("S", 0).AppendI("T", 0)
.AppendComment("Set minimum extrude and travel feed rate in mm/sec");
}
}
}
static GCodeFile generate_cnc_test(MeshPlanarMillSlicer.Result sliceSets, RepRapSettings settings, out ToolpathSet AccumulatedPaths)
{
int PLUNGE_SPEED = 800;
AccumulatedPaths = new ToolpathSet();
GCodeFileAccumulator file_accumulator = new GCodeFileAccumulator();
GCodeBuilder builder = new GCodeBuilder(file_accumulator);
BaseThreeAxisMillingCompiler Compiler = new BaseThreeAxisMillingCompiler(builder, settings, GenericMillingAssembler.Factory);
Compiler.Begin();
/*
* Clearing pass
*/
PlanarSliceStack clearingSlices = sliceSets.Clearing;
int N = clearingSlices.Count;
// assuming origin is at top of stock so we actaully are going down in Z layers
for (int k = 0; k < N; ++k)
{
clearingSlices[k].Z = -(sliceSets.TopZ - clearingSlices[k].Z);
}
for (int layeri = 0; layeri < N; layeri++)
{
PlanarSlice slice = clearingSlices[layeri];
Compiler.AppendComment(string.Format("clearing layer {0} - {1}mm", layeri, slice.Z));
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
layer_builder.Initialize(Compiler.ToolPosition);
// To do a layer-change, we need to plunge down at the first scheduled cutting position.
// However we will not know that until we schedule the first set of paths.
// So, we configure SequentialScheduler2d to call this function when it knows this information,
// and then we can travel to the new XY position before we plunge to new Z
Action <List <FillCurveSet2d>, SequentialScheduler2d> DoZChangeF = (curves, scheduler) => {
Vector2d startPosXY = (curves[0].Loops.Count > 0) ?
curves[0].Loops[0].Start : curves[0].Curves[0].Start;
Vector3d startPosXYZ = new Vector3d(startPosXY.x, startPosXY.y, slice.Z);
// TODO: we should retract at faster speed here? maybe use custom function that does this better?
layer_builder.AppendTravel(startPosXYZ, PLUNGE_SPEED);
scheduler.OnAppendCurveSetsF = null;
};
SequentialScheduler2d layerScheduler = new SequentialScheduler2d(layer_builder, settings)
{
ExtrudeOnShortTravels = true,
ShortTravelDistance = settings.Machine.NozzleDiamMM * 1.5
};
layerScheduler.OnAppendCurveSetsF = DoZChangeF;
GroupScheduler2d groupScheduler = new GroupScheduler2d(layerScheduler, Compiler.ToolPosition.xy);
foreach (GeneralPolygon2d shape in slice.Solids)
{
ShellsFillPolygon shells_gen = new ShellsFillPolygon(shape)
{
PathSpacing = settings.ShellsFillPathSpacingMM(),
ToolWidth = settings.Machine.NozzleDiamMM,
Layers = 10,
OuterShellLast = false,
DiscardTinyPerimterLengthMM = 1, DiscardTinyPolygonAreaMM2 = 1
};
shells_gen.Compute();
groupScheduler.BeginGroup();
groupScheduler.AppendCurveSets(shells_gen.Shells);
groupScheduler.EndGroup();
}
Compiler.AppendPaths(layer_builder.Paths, settings);
AccumulatedPaths.Append(layer_builder.Paths);
}
/*
* Horizontal finish pass
*/
PlanarSliceStack horzSlices = sliceSets.HorizontalFinish;
int NH = horzSlices.Count;
// assuming origin is at top of stock so we actaully are going down in Z layers
for (int k = 0; k < NH; ++k)
{
horzSlices[k].Z = -(sliceSets.TopZ - horzSlices[k].Z);
}
for (int layeri = 0; layeri < NH; layeri++)
{
PlanarSlice slice = horzSlices[layeri];
Compiler.AppendComment(string.Format("horz finish layer {0} - {1}mm", layeri, slice.Z));
ToolpathSetBuilder layer_builder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
layer_builder.Initialize(Compiler.ToolPosition);
Action <List <FillCurveSet2d>, SequentialScheduler2d> DoZChangeF = (curves, scheduler) => {
Vector2d startPosXY = (curves[0].Loops.Count > 0) ?
curves[0].Loops[0].Start : curves[0].Curves[0].Start;
Vector3d startPosXYZ = new Vector3d(startPosXY.x, startPosXY.y, slice.Z);
// TODO: we should retract at faster speed here? maybe use custom function that does this better?
layer_builder.AppendTravel(startPosXYZ, PLUNGE_SPEED);
scheduler.OnAppendCurveSetsF = null;
};
SequentialScheduler2d layerScheduler = new SequentialScheduler2d(layer_builder, settings)
{
ExtrudeOnShortTravels = true,
ShortTravelDistance = settings.Machine.NozzleDiamMM * 1.5
};
layerScheduler.OnAppendCurveSetsF = DoZChangeF;
GroupScheduler2d groupScheduler = new GroupScheduler2d(layerScheduler, Compiler.ToolPosition.xy);
foreach (GeneralPolygon2d shape in slice.Solids)
{
ShellsFillPolygon shells_gen = new ShellsFillPolygon(shape)
{
//InsetFromInputPolygonX = 0.0,
PathSpacing = settings.ShellsFillPathSpacingMM(),
ToolWidth = settings.Machine.NozzleDiamMM,
Layers = 10,
OuterShellLast = false,
PreserveInputInsetTopology = false,
DiscardTinyPerimterLengthMM = 1, DiscardTinyPolygonAreaMM2 = 1
};
shells_gen.Compute();
groupScheduler.BeginGroup();
groupScheduler.AppendCurveSets(shells_gen.Shells);
groupScheduler.EndGroup();
}
Compiler.AppendPaths(layer_builder.Paths, settings);
AccumulatedPaths.Append(layer_builder.Paths);
}
// return to home position
ToolpathSetBuilder finishBuilder = new ToolpathSetBuilder()
{
MoveType = ToolpathTypes.Cut
};
finishBuilder.Initialize(Compiler.ToolPosition);
finishBuilder.AppendTravel(Vector3d.Zero, PLUNGE_SPEED);
Compiler.AppendPaths(finishBuilder.Paths, settings);
Compiler.End();
return(file_accumulator.File);
}
