/// <summary>
/// Traverses axis in a full range several times.
/// </summary>
public static PlanBuilder BackAndForwardAxisTraversal()
{
var traverseDelta = 400;
var builder = new PlanBuilder();
for (var i = 0; i < 30; ++i)
{
var distance = Constants.MaxStepsX;
var acceleration = Coord2DController.CreateAcceleration(Constants.StartDeltaT, traverseDelta)[0];
var deceleration = Coord2DController.CreateAcceleration(traverseDelta, Constants.StartDeltaT)[0];
distance -= Math.Abs(acceleration.StepCount);
distance -= Math.Abs(deceleration.StepCount);
if (i % 2 == 0)
{
builder.AddXY(acceleration, null);
builder.AddConstantSpeedTransitionXY(distance, 0, Speed.FromDeltaT(traverseDelta));
builder.AddXY(deceleration, null);
}
else
{
builder.AddXY(acceleration.WithReversedDirection(), null);
builder.AddConstantSpeedTransitionXY(-distance, 0, Speed.FromDeltaT(traverseDelta));
builder.AddXY(deceleration.WithReversedDirection(), null);
}
}
builder.ChangeXYtoUV();
return(builder);
}
protected void Initialize()
{
_random = new RandomNumberGenerator(0);
_dmeBuilder = new DmeBuilder(_random);
_designModelBuilder = new DesignModelBuilder(_random);
_designModelSize = 50;
_planBuilder = new PlanBuilder(_random);
}
public void Initialize()
{
_random = new RandomNumberGenerator(0);
_dmeBuilder = new DmeBuilder(_random);
_designModelBuilder = new DesignModelBuilder(_random);
_planBuilder = new PlanBuilder(_random);
_toolCoverageCalculatorMock = new Mock <IToolCoverageCalculator>();
}
/// <summary>
/// Demo with several acceleration ramps.
/// </summary>
public static PlanBuilder Ramping()
{
var builder = new PlanBuilder();
builder.AddTransitionRPM(-400 * 10, 0, 1000, 500);
builder.AddTransitionRPM(-400 * 10, 500, 500, 500);
builder.AddTransitionRPM(-400 * 20, 500, 1500, 0);
return(builder);
}
private void AlignHeads_Click(object sender, RoutedEventArgs e)
{
var state = Cnc.PlannedState;
var xSteps = state.X - state.U;
var ySteps = state.Y - state.V;
var builder = new PlanBuilder();
builder.AddRampedLineXY(-xSteps, -ySteps, Constants.MaxPlaneAcceleration, Constants.MaxPlaneSpeed);
Cnc.SEND(builder.Build());
}
public void Disposes_results()
{
var plan = new PlanBuilder();
var aDisposable = new MyDisposable();
var create = plan.Add("Create", () => aDisposable);
plan.Add("Use", (MyDisposable _) => { }, create);
plan.Build().Invoke();
Check.That(() => aDisposable.IsDisposed);
}
/// <summary>
/// Demo with a single revolution interrupted several times.
/// </summary>
public static PlanBuilder InterruptedRevolution()
{
var plan = new PlanBuilder();
var segmentation = 100;
for (var i = 0; i < 400 / segmentation; ++i)
{
plan.AddRampedLineXY(segmentation, segmentation, Constants.MaxPlaneAcceleration, Constants.MaxPlaneSpeed);
}
return(plan);
}
public SyncPlan BuildPlan(IEnumerable <string> paths, Mask mask)
{
Analyze(paths, mask);
PlanBuilder builder = new PlanBuilder(_tager, mask);
var plan = builder.Build(NotSynchronizedFiles.Keys);
foreach (var errorFile in builder.ErrorFiles)
{
ErrorFiles.Add(errorFile.Key, errorFile.Value);
}
return(plan);
}
private void GoToZeros_Click(object sender, RoutedEventArgs e)
{
var state = Cnc.PlannedState;
var stepsU = _positionOffsetU - state.U;
var stepsV = _positionOffsetV - state.V;
var stepsX = _positionOffsetX - state.X;
var stepsY = _positionOffsetY - state.Y;
var planner = new PlanBuilder();
planner.AddRampedLineUVXY(stepsU, stepsV, stepsX, stepsY, Constants.MaxPlaneAcceleration, Constants.MaxPlaneSpeed);
Cnc.SEND(planner.Build());
}
private void executePlan()
{
if (!Cnc.IsHomeCalibrated)
{
ShowError("Calibration is required!");
return;
}
disableMotionCommands();
Workspace.DisableChanges();
var builder = new PlanBuilder();
var point = Workspace.EntryPoint;
var state = Cnc.PlannedState;
var initU = point.PositionC1 - state.U;
var initV = point.PositionC2 - state.V;
var initX = point.PositionC1 - state.X;
var initY = point.PositionC2 - state.Y;
builder.AddRampedLineUVXY(initU, initV, initX, initY, Configuration.MaxPlaneAcceleration, getTransitionSpeed());
try
{
Workspace.BuildPlan(builder);
}
catch (PlanningException ex)
{
planCompleted();
ShowError(ex.Message);
return;
}
//builder.AddRampedLineUVXY(-initU, -initV, -initX, -initY, Constants.MaxPlaneAcceleration, getTransitionSpeed());
var plan = builder.Build();
if (!Cnc.SEND(plan))
{
planCompleted();
ShowError("Plan overflows the workspace!");
return;
}
Cnc.OnInstructionQueueIsComplete += planCompleted;
_planStart = DateTime.Now;
_isPlanRunning = true;
if (!plan.Any())
{
planCompleted();
}
}
/// <summary>
/// Draws a square filled with diagonals - uses 45 degree acceleration methods
/// </summary>
public static PlanBuilder DrawSquareWithDiagonals()
{
var speed = Constants.MaxPlaneSpeed;
var acceleration = Constants.MaxPlaneAcceleration; //new Acceleration(Constants.MaxPlaneAcceleration.Speed,Constants.MaxPlaneAcceleration.Ticks*10);
var squareSize = 6000;
var diagonalDistance = 300;
var builder = new PlanBuilder();
//do a square border
builder.AddRampedLineXY(squareSize, 0, acceleration, speed);
builder.AddRampedLineXY(0, squareSize, acceleration, speed);
builder.AddRampedLineXY(-squareSize, 0, acceleration, speed);
builder.AddRampedLineXY(0, -squareSize, acceleration, speed);
//left right diagonals
var diagonalCount = squareSize / diagonalDistance;
for (var i = 0; i < diagonalCount * 2; ++i)
{
var diagLength = (diagonalCount - Math.Abs(i - diagonalCount)) * diagonalDistance;
if (i % 2 == 0)
{
builder.AddRampedLineXY(-diagLength, diagLength, acceleration, speed);
if (i < diagonalCount)
{
builder.AddRampedLineXY(0, diagonalDistance, acceleration, speed);
}
else
{
builder.AddRampedLineXY(diagonalDistance, 0, acceleration, speed);
}
}
else
{
builder.AddRampedLineXY(diagLength, -diagLength, acceleration, speed);
if (i < diagonalCount)
{
builder.AddRampedLineXY(diagonalDistance, 0, acceleration, speed);
}
else
{
builder.AddRampedLineXY(0, diagonalDistance, acceleration, speed);
}
}
}
return(builder);
}
private void Execute(IEnumerable <InstructionCNC> plan, bool duplicateUV = true)
{
if (duplicateUV)
{
var builder = new PlanBuilder();
builder.Add(plan);
builder.DuplicateXYtoUV();
_cnc.SEND(builder.Build());
}
else
{
_cnc.SEND(plan);
}
}
/// <summary>
/// A single revolution with a lot of forward/backward direction changes.
/// </summary>
/// <returns></returns>
public static PlanBuilder BackAndForwardRevolution()
{
var plan = new PlanBuilder();
var overShoot = 100;
var segmentation = 4;
for (var i = 0; i < 400 / segmentation; ++i)
{
plan.AddRampedLineXY(-overShoot, -overShoot, Constants.MaxPlaneAcceleration, Constants.MaxPlaneSpeed);
plan.AddRampedLineXY(segmentation + overShoot, segmentation + overShoot, Constants.MaxPlaneAcceleration, Constants.MaxPlaneSpeed);
}
return(plan);
}
/// <summary>
/// Builds plan configured by the workspace.
/// ASSUMING the starting position be correctly set up on <see cref="EntryPoint"/>.
/// </summary>
internal void BuildPlan(PlanBuilder plan)
{
var speedPoints = new List <Speed4Dstep>();
_entryPoint.Build(this, speedPoints, null);
var planPoints = speedPoints.Select(p => p.Point).ToList();
var segmentSpeeds = speedPoints.Select(p => Tuple.Create(p.SpeedUV, p.SpeedXY)).ToArray();
//scheduler needs referential point
planPoints.Insert(0, _entryPoint.CutPoints.First());
var scheduler = new StraightLinePlanner4D(CuttingSpeed);
var trajectoryPlan = scheduler.CreateConstantPlan(new Trajectory4D(planPoints), segmentSpeeds);
plan.Add(trajectoryPlan.Build());
}
internal static AccelerationInstruction[] CreateAcceleration(int speed, int desiredSpeed)
{
var canSkipAcceleration = speed == desiredSpeed;
canSkipAcceleration |= Math.Abs(speed) >= Configuration.StartDeltaT && Math.Abs(desiredSpeed) >= Configuration.StartDeltaT;
if (canSkipAcceleration)
{
//no acceleration is required
return(new AccelerationInstruction[0]);
}
if (Math.Abs(Math.Sign(speed) - Math.Sign(desiredSpeed)) > 1)
{
throw new NotImplementedException("Stop and run in other direction");
}
var stepCount = desiredSpeed > 0 ? (Int16)5000 : (Int16)(-5000);
if (desiredSpeed == 0)
{
stepCount = speed > 0 ? (Int16)5000 : (Int16)(-5000);
}
speed = Math.Abs(speed);
desiredSpeed = Math.Abs(desiredSpeed);
if (speed == 0)
{
speed = Configuration.StartDeltaT;
}
if (desiredSpeed == 0)
{
desiredSpeed = Configuration.StartDeltaT;
}
var acceleration = PlanBuilder.CalculateBoundedAcceleration((UInt16)speed, (UInt16)desiredSpeed, stepCount);
return(new AccelerationInstruction[] { acceleration });
}
public Plan ToSDKPlan()
{
if (sdkPlan != null)
{
return(sdkPlan);
}
else if (apiPlan != null)
{
PlanBuilder builder = PlanBuilder.NewPlan(apiPlan.Name)
.WithContract(apiPlan.Contract)
.WithData(apiPlan.Data)
.WithId(apiPlan.Id)
.WithCycle(apiPlan.Cycle)
.WithDescription(apiPlan.Description)
.WithFeatures(apiPlan.Features)
.WithGroup(apiPlan.Group)
.WithOriginal(apiPlan.Original)
.WithPrice(new PriceConverter(apiPlan.Price).ToSDKPrice());
if (apiPlan.FreeCycles != null)
{
builder.WithFreeCycles(apiPlan.FreeCycles.Count, apiPlan.FreeCycles.Cycle);
}
if (apiPlan.Quotas != null && apiPlan.Quotas.Count > 0)
{
foreach (API.Quota quota in apiPlan.Quotas)
{
builder.WithQuota(quota.Cycle, quota.Limit, quota.Scope, quota.Target);
}
}
return(builder.Build());
}
else
{
return(null);
}
}
private void setElevation(CenterCutState newState)
{
if (_state == newState)
{
//there is nothing to do
return;
}
var elevationFactor = _state - newState;
_state = newState;
refreshStateButtons();
var elevation = double.Parse(Elevation.Text);
var elevationSteps = (int)Math.Round(elevation / Configuration.MilimetersPerStep) * elevationFactor;
var builder = new PlanBuilder();
builder.AddRampedLineUVXY(elevationSteps, 0, -elevationSteps, 0, Configuration.MaxPlaneAcceleration, Configuration.MaxPlaneSpeed);
var plan = builder.Build();
_panel.Cnc.SEND(plan);
}
private void Execute(PlanBuilder plan, bool duplicateUV = true)
{
Execute(plan.Build(), duplicateUV);
}
public void withSpecifiedValues()
{
AccountBuilder accountBuilder = AccountBuilder.NewAccount()
.WithName(ACC_NAME)
.WithId(ACC_ID)
.WithOwner(ACC_OWNER)
.WithLogoUrl(ACC_LOGOURL)
.WithData(ACC_DATA)
.WithCompany(CompanyBuilder.NewCompany(ACC_CO_NAME)
.WithAddress(AddressBuilder.NewAddress()
.WithAddress1(ACC_CO_ADDR_ADDR1)
.WithAddress2(ACC_CO_ADDR_ADDR2)
.WithCity(ACC_CO_ADDR_CITY)
.WithCountry(ACC_CO_ADDR_COUNTRY)
.WithState(ACC_CO_ADDR_STATE)
.WithZipCode(ACC_CO_ADDR_ZIP).Build())
.WithId(ACC_CO_ID)
.WithData(ACC_CO_DATA)
.Build())
.WithCustomField(CustomFieldBuilder.CustomFieldWithId(ACC_FIELD_ID)
.WithDefaultValue(ACC_FIELD_DEF_VLE)
.IsRequired(ACC_FIELD_IS_REQUIRED)
.WithTranslation(TranslationBuilder.NewTranslation(ACC_FIELD_TRANSL_LANG).Build())
.Build())
.WithLicense(LicenseBuilder.NewLicense()
.CreatedOn(ACC_LIC_CREATED)
.WithPaidUntil(ACC_LIC_PAIDUNTIL)
.WithStatus(ACC_LIC_STATUS)
.WithTransaction(ACC_LIC_TRANS_CREATED,
CreditCardBuilder.NewCreditCard()
.WithCvv(ACC_LIC_TRANS_CC_CVV)
.WithName(ACC_LIC_TRANS_CC_NAME)
.WithNumber(ACC_LIC_TRANS_CC_NUM)
.WithType(ACC_LIC_TRANS_CC_TYPE)
.WithExpiration(ACC_LIC_TRANS_CC_EXP_MONTH, ACC_LIC_TRANS_CC_EXP_YEAR)
.Build(),
PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_TRANS_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_TRANS_PRICE_CURR_ID, ACC_LIC_TRANS_PRICE_CURR_NAME,
ACC_LIC_TRANS_PRICE_CURR_DATA)
.Build())
.WithPlan(PlanBuilder.NewPlan(ACC_LIC_PLAN_ID)
.WithId(ACC_LIC_PLAN_NAME)
.WithContract(ACC_LIC_PLAN_CONTRACT)
.WithDescription(ACC_LIC_PLAN_DES)
.WithGroup(ACC_LIC_PLAN_GRP)
.WithCycle(ACC_LIC_PLAN_CYC)
.WithOriginal(ACC_LIC_PLAN_ORI)
.WithData(ACC_LIC_PLAN_DATA)
.WithFreeCycles(ACC_LIC_PLAN_CYC_COUNT, ACC_LIC_PLAN_CYC_CYCLE)
.WithQuota(ACC_LIC_PLAN_QUOTA_CYCLE, ACC_LIC_PLAN_QUOTA_LIMIT, ACC_LIC_PLAN_QUOTA_SCOPE,
ACC_LIC_PLAN_QUOTA_TARGET)
.WithFeatures(ACC_LIC_PLAN_FEAT)
.WithPrice(PriceBuilder.NewPrice()
.WithAmount(ACC_LIC_PLAN_PRICE_AMOUNT)
.WithCurrency(ACC_LIC_PLAN_PRICE_CURR_ID, ACC_LIC_PLAN_PRICE_CURR_NAME,
ACC_LIC_PLAN_PRICE_CURR_DATA)
.Build())
.Build())
.Build())
.WithAccountProviders(new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_DOC_NAME)
.WithData(ACC_PROV_DOC_DATA)
.WithId(ACC_PROV_DOC_ID)
.WithProvides(ACC_PROV_DOC_NAME)
.Build()
}, new List <Provider>()
{
ProviderBuilder.NewProvider(ACC_PROV_USR_NAME)
.WithData(ACC_PROV_USR_DATA)
.WithId(ACC_PROV_USR_ID)
.WithProvides(ACC_PROV_USR_PROVIDES)
.Build()
});
Account account = accountBuilder.Build();
Assert.AreEqual(ACC_NAME, account.Name);
Assert.AreEqual(ACC_CO_ID, account.Company.Id);
Assert.AreEqual(ACC_CO_ADDR_ADDR1, account.Company.Address.Address1);
Assert.AreEqual(1, account.CustomFields.Count);
Assert.AreEqual(ACC_FIELD_DEF_VLE, account.CustomFields[0].Value);
Assert.AreEqual(1, account.CustomFields[0].Translations.Count);
Assert.AreEqual(ACC_FIELD_TRANSL_LANG, account.CustomFields[0].Translations[0].Language);
Assert.AreEqual(1, account.Licenses.Count);
Assert.AreEqual(ACC_LIC_STATUS, account.Licenses[0].Status);
Assert.AreEqual(1, account.Licenses[0].Transactions.Count);
Assert.AreEqual(ACC_LIC_TRANS_CC_NUM, account.Licenses[0].Transactions[0].CreditCard.Number);
Assert.AreEqual(ACC_LIC_TRANS_PRICE_AMOUNT, account.Licenses[0].Transactions[0].Price.Amount);
Assert.AreEqual(ACC_LIC_PLAN_CONTRACT, account.Licenses[0].Plan.Contract);
Assert.AreEqual(ACC_LIC_PLAN_PRICE_AMOUNT, account.Licenses[0].Plan.Price.Amount);
Assert.AreEqual(1, account.Providers.Documents.Count);
Assert.AreEqual(ACC_PROV_DOC_NAME, account.Providers.Documents[0].Name);
Assert.AreEqual(1, account.Providers.Users.Count);
Assert.AreEqual(ACC_PROV_USR_NAME, account.Providers.Users[0].Name);
}
/// <summary>
/// plan ::= "(" [ "(" <docstring> ]
/// ( ( "(" <competence> | <action-pattern> )*
/// "(" <drive-collection>
/// ( "(" <competence> | <action-pattern> )*
/// )
/// | ( "(" <competence> )
/// | ( "(" <action-pattern> )
/// ")"
/// </summary>
/// <returns>A plan builder object representing the parsed plan.</returns>
protected internal PlanBuilder Plan()
{
PlanBuilder planBuilder = new PlanBuilder();
// this method cheats a bit by counting the action-pattern
// and competences and also drive-collections to check when things are
// allowed were.
if (!Match(new string[] { "LPAREN", }))
{
Error(string.Format("Plan needs to start with '(' rather than '{0}'", token.value));
}
NextToken();
// action pattern, competence, docstring, drive collection
int ap = 0, c = 0, d = 0, dc = 0;
while (true)
{
if (!Match(new string[] { "LPAREN", "RPAREN" }))
{
Error(string.Format("Expected '(' as start of documentation / " +
"competence / action-pattern / drive-collection, or " +
"')' to end plan, instead of '{0}'", token.value));
}
if (Match(new string[] { "RPAREN", }))
{
// end of plan
NextToken();
break;
}
NextToken();
// check for documentation
if (Match(new string[] { "DOC", }))
{
if (ap + c + dc + d > 0)
{
Error("Documentation only allowed as first " +
"element in plan");
}
d += 1;
planBuilder.setDocString(GetDocString());
// print docString();
}
// check for competence
else if (Match(new string[] { "C", }))
{
c++;
planBuilder.addCompetence(GetCompetence());
// print competence()
}
// check for action-pattern
else if (Match(new string[] { "AP", }))
{
ap++;
planBuilder.addActionPattern(GetActionPattern());
// print actionPattern();
}
// check for drive-collection
else if (Match(new string[] { "DC", "RDC", "SDC", "SRDC" }))
{
if (dc > 0)
{
Error("Only a single drive-collection allowed");
}
dc++;
planBuilder.SetDriveCollection(GetDriveCollection());
// print
}
else
{
Error(string.Format("Expected docstring / competence / action " +
"pattern or drive collection instead of '{0}'", token.value));
}
}
// the plan was closed
if (token is Token)
{
Error(string.Format("Illegal token '{0}' after end of plan", token.value));
}
if (dc == 0 && (ap + c) != 1)
{
Error("Illegal plan: A plan without a drive-collection " +
"only allows for a SINLGE action-pattern OR a SINGLE competence");
}
// everything is fine
return(planBuilder);
}
