private static void OneDirectionHorizontal(MoveActionCollection programPhase, double currentZ, double returnZ, double xIni, double xFin, double yIni, double yFin, double larghezzaPassata)
{
var currentY = yIni;
while (currentY > yFin)
{
currentY -= larghezzaPassata;
if (currentY < yFin)
{
currentY = yFin;
}
// Mi sposto sopra punto attaco
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, xIni, currentY, null);
// Vado a Z sicurezza
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, returnZ);
// Vado a z di lavoro
programPhase.AddLinearMove(MoveType.SecureRapidFeed, AxisAbilited.Z, null, null, currentZ);
// Movimento di lavoro
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xFin, null, null);
// Stacco in rapido
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, returnZ);
}
}
protected MoveActionCollection GetFinalProgram(MoveActionCollection moveActionCollection)
{
var rslt = new MoveActionCollection();
var preview = moveActionCollection;
if (RotationAbilited)
{
//Angoli in degreesss...!!
var angleStep = 360 / NumberInstance;
for (int i = 1; i <= NumberInstance; i++)
{
var angleCurrent = (angleStep * i) + FirstAngle;
var rotationMatrix = new Matrix3D();
rotationMatrix.RotateAt(new Quaternion(new Vector3D(0, 0, 1), angleCurrent),
new System.Windows.Media.Media3D.Point3D(CenterRotationX, CenterRotationY, 0));
foreach (var entity2D in preview)
{
rslt.Add(entity2D.MultiplyMatrix(rotationMatrix));
}
}
}
else if (TranslateAbilited)
{
var stepX = TransStepX;
var stepY = TransStepY;
for (int i = 0; i < TransCountY; i++)
{
var yMultiplier = stepY * i;
for (int j = 0; j < TransCountX; j++)
{
var xMultiplier = stepX * j;
var rotationMatrix = new Matrix3D();
rotationMatrix.Translate(new Vector3D(xMultiplier, yMultiplier, 0));
foreach (var entity2D in preview)
{
rslt.Add(entity2D.MultiplyMatrix(rotationMatrix));
}
}
}
}
else
{
return(preview);
}
return(rslt);
}
//internal override Utensile CreateTool(LavorazioniEnumOperazioni enumOperationType)
//{
// var unit = Singleton.Instance.MeasureUnit;
// return FresaturaHelper.CreateTool((LavorazioniEnumOperazioni)enumOperationType, unit);
//}
//internal override List<Utensile> GetCompatibleTools(LavorazioniEnumOperazioni operationType, MagazzinoUtensile magazzino)
//{
// var unit = Singleton.Instance.MeasureUnit;
// return magazzino.GetTools<FresaCandela>(unit).Cast<Utensile>().ToList();
//}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
// var fresa = operazione.Utensile as IDiametrable;
//var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
//if (fresa == null || parametro == null)
// throw new NullReferenceException();
//var diaFresa = fresa.Diametro;
//var larghezzaPassata = parametro.GetLarghezzaPassata();
//var profPassata = parametro.GetProfonditaPassata();
var moveCollection = new MoveActionCollection();
switch ((LavorazioniEnumOperazioni)operazione.OperationType)
{
default:
{
EngravingText(moveCollection, GetTextProfiles(), ProfonditaLavorazione, SicurezzaZ, InizioLavorazioneZ);
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var diametrable = operazione.Utensile as IDiametrable;
var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
if (diametrable == null)
{
return;
}
var diaFresa = diametrable.Diametro;
double profPassata = 0;
double larghezzaPassata = 0;
if (parametro != null)
{
profPassata = parametro.GetProfonditaPassata();
larghezzaPassata = parametro.GetLarghezzaPassata();
}
var moveCollection = new MoveActionCollection();
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.Sgrossatura:
{
MillProgrammingHelper.FresaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, Larghezza, SicurezzaZ, InizioLavorazioneZ, diaFresa, larghezzaPassata, profPassata, ExtraCorsa, SovrametalloFinituraProfilo, FinishWithCompensation);
} break;
case LavorazioniEnumOperazioni.Finitura:
{
MillProgrammingHelper.FresaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, Larghezza, SicurezzaZ, InizioLavorazioneZ, diaFresa, larghezzaPassata, profPassata, ExtraCorsa, 0, FinishWithCompensation);
} break;
case LavorazioniEnumOperazioni.Smussatura:
{
FresaturaSmussaturaScanalaturaChiusaProgram(moveCollection, GetProfile(), ProfonditaLavorazione, SicurezzaZ, InizioLavorazioneZ, diaFresa, Larghezza);
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
//internal override ProgramPhase GetOperationProgram(Operazione operazione)
//{
// /*
// * il richiamo degli utensili magari farlo e delle operazioni comuni magari farlo in astratto più a monte
// *
// */
// /*
// *
// * su spianatura tradizionale se rimane ultima passata piccola lo togle con il centro della fresa.
// */
// var program = new ProgramPhase(SicurezzaZ);
// // cambio utensile // se
// var toolChange = new ChangeToolAction(program, operazione);
// program.ActiveAsseC(true);
// var parametro = operazione.GetParametro<ParametroFresaSpianare>();
// if (parametro == null)
// throw new NullReferenceException();
// var larghezzaPassata = parametro.GetLarghezzaPassata();
// var profPassata = parametro.GetProfonditaPassata();
// var diaFresa = parametro.DiametroMinimoFresa;
// diaFresa -= parametro.GetRaggioInserto() * 2;
// var diaIngombroFresa = parametro.DiametroIngombroFresa;
// var secureFeed = 1;
// var extraCorsa = 1;
// var feed = parametro.GetFeed(FeedType.ASync);
// var sovraMetallo = Sovrametallo - SovrametalloPerFinitura;
// var ottimizza = false; // per ora non lo lascio modificare da utente
// var passataMinimaPercentuale = 20.0d; // -- ,, valori sballati potrebbero causare bug non previsti
// if (feed <= 0)
// return null;
// var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, secureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// {MoveType.PlungeFeed, feed /2}
// };
// program.SetFeedDictionary(feedDictionary);
// var moveCollection = new MoveActionCollection();
// var centerPoint = GetCenterPoint();
// switch ((LavorazioniEnumOperazioni)operazione.OperationType)
// {
// case LavorazioniEnumOperazioni.FresaturaSpianaturaSgrossatura:
// {
// var zLavoro = LivelloZ + SovrametalloPerFinitura;
// switch (ModoSgrossatura)
// {
// case SpiantaturaMetodologia.Tradizionale:
// {
// OneDirectionFaceMilling(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, extraCorsa);
// } break;
// case SpiantaturaMetodologia.Spirale:
// {
// SpiralFaceMillingV2(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, extraCorsa, ottimizza, passataMinimaPercentuale);
// } break;
// }
// } break;
// case LavorazioniEnumOperazioni.FresaturaSpianaturaFinitura:
// {
// switch (ModoFinitura)
// {
// case SpiantaturaMetodologia.Tradizionale:
// {
// OneDirectionFaceMilling(moveCollection,
// centerPoint.X, centerPoint.Y,
// Larghezza, Altezza, larghezzaPassata,
// diaFresa,
// diaIngombroFresa,
// SovrametalloPerFinitura,
// profPassata,
// LivelloZ,
// SicurezzaZ,
// extraCorsa
// );
// } break;
// case SpiantaturaMetodologia.Spirale:
// {
// // richiamo stesso procedimento , metto solo profondita == sovrametallo
// // magari fare spiarale singolo in un metodo e richiamarla con sgrossatura più volte
// SpiralFaceMillingV2(moveCollection,
// centerPoint.X, centerPoint.Y,
// Larghezza, Altezza,
// larghezzaPassata,
// diaFresa,
// diaIngombroFresa,
// SovrametalloPerFinitura,
// profPassata,
// LivelloZ, SicurezzaZ, extraCorsa,
// ottimizza,
// passataMinimaPercentuale);
// } break;
// }
// } break;
// }
// var mm = base.GetFinalProgram(moveCollection);
// foreach (var variable in mm)
// {
// program.AddMoveAction(variable);
// }
// program.ActiveAsseC(false);
// return program;
//}
private static void OneDirectionFaceMilling(MoveActionCollection programPhase,
double offsetX, double offsetY,
double larghezza, double altezza,
double larghPassata, double diaFresa, double diaIngombroFresa,
double sovraMetallo, double profPassata,
double zFinale, double zSicurezza,
double extraCorsaSicurezza)
{
if (CheckValueHelper.GreatherOrEqualZero(new[] { sovraMetallo, extraCorsaSicurezza }) ||
CheckValueHelper.GreatherThanZero(new[] { larghezza, altezza, larghPassata, diaFresa, diaIngombroFresa, profPassata, }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zFinale + sovraMetallo),
new KeyValuePair <double, double>(diaFresa, larghPassata),
})
)
{
return;
}
var zCurrent = zFinale + sovraMetallo;
var xIni = offsetX - larghezza / 2;
var xFin = offsetX + larghezza / 2;
var yIni = offsetY + altezza / 2 + diaFresa / 2;
var yFin = offsetY - altezza / 2;
xIni -= (diaIngombroFresa / 2) + extraCorsaSicurezza;
xFin += (diaIngombroFresa / 2) + extraCorsaSicurezza;
// Itero per tutte le passate in Z
while (zCurrent > zFinale)
{
zCurrent -= profPassata;
if (zCurrent < zFinale)
{
zCurrent = zFinale;
}
{
OneDirectionHorizontal(programPhase, zCurrent, zSicurezza, xIni, xFin, yIni, yFin, larghPassata);
}
}
/*
* Pensare a come riutilizzarla per direzione orizzontale e verticale
*/
}
/*
* mi serve
* 1- metodo che mi restituisca i profili calcolati
*
*
*
*/
//private static List<Profile2D> CalculateInternOffset(Profile2D origin, double offsetValue, double diameterValue)
//{
// offsetValue = -Math.Abs(offsetValue);
// var firstPaths = origin.Offset(-diameterValue, false);
// if (firstPaths == null)
// return null;
// var rslt = new List<Profile2D>();
// foreach (var firstPath in firstPaths)
// {
// rslt.Add(firstPath);
// RicorsivaGenerateInternOffset(firstPath, offsetValue, false, ref rslt);
// }
// return rslt;
//}
//private static void RicorsivaGenerateInternOffset(Profile2D profile2D, double offset, bool clockwise, ref List<Profile2D> profile2DsList)
//{
// // Calcola offset , ritorna 1 o più contorni
// var offsetRslt = profile2D.Offset(offset, clockwise);
// // se non ritorna più niente termina metodo
// if (offsetRslt == null)
// return;
// foreach (var singleContour in offsetRslt)
// {
// profile2DsList.Add(singleContour);
// RicorsivaGenerateInternOffset(singleContour, offset, clockwise, ref profile2DsList);
// }
//}
private static void FresaturaSmussaturaScanalaturaChiusaProgram(MoveActionCollection moveActionCollection, Profile2D profile2D, double profonditaSmusso, double zSicurezza, double zIniziale, double diaFresa, double larghezzaScanaltura)
{
/*
* teoria.
* - Prendo profilo
* - Se valido faccio offset negativo del raggio della fresa
* - Poi faccio offset della larghezza di passata fino a che il metodo non mi restituisce più niente. ( ho raggiunto il massimo )
*/
/*
* Controllo Valori
*/
if (CheckValueHelper.GreatherThanZero(new[] { profonditaSmusso, diaFresa, larghezzaScanaltura }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zIniziale),
})
)
{
return;
}
if (profile2D == null)
{
return;
}
/*
* chiamo metodo comune per 2 profili (maggiore e minore della fresatura di scanalatura)
*/
var offsetValue = larghezzaScanaltura / 2;
var profileExt = profile2D.Offset(offsetValue, true);
var profileInt = profile2D.Offset(-offsetValue, true);
if ((profileExt == null || profileExt.Count == 0) ||
(profileInt == null || profileInt.Count == 0))
{
return;
}
MillProgrammingHelper.GetExterChamfer(moveActionCollection, profileInt[0], null, false, profonditaSmusso, diaFresa, 0, false, zIniziale, zSicurezza);
MillProgrammingHelper.GetInternChamfer(moveActionCollection, profileExt[0], profonditaSmusso, diaFresa, 0, false, zIniziale, zSicurezza);
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var moveCollection = new MoveActionCollection();
var parametro = operazione.Utensile.ParametroUtensile as ParametroUtensileTornitura;
if (parametro == null)
{
return;
}
// La profondità di passata = x2
var profPassata = parametro.ProfonditaPassata * 2;
var preference = Singleton.Preference.GetPreference(Singleton.Instance.MeasureUnit);
var distacco = preference.DistaccoSgrossaturaTornitura;
var profile2D = Profile.GetProfileResult(false);
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraSgrossatura:
{
TurnProgrammingHelper.GetRoughingTurnProgram(programPhase, moveCollection, profile2D, profPassata, ExtraCorsa, distacco, _tipoTornitura, UsaMacroSgrossatura, SovrametalloFinituraX, SovrametalloFinituraY);
}
break;
case LavorazioniEnumOperazioni.TornituraFinitura:
{
TurnProgrammingHelper.GetFinishingProgram(moveCollection, profile2D, _tipoTornitura, ExtraCorsa);
}
break;
default:
Trace.WriteLine("Tornitura.CreateSpecificProgram");
break;
}
foreach (var variable in moveCollection)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var moveCollection = new MoveActionCollection();
var zStart = InizioZ + Sovrametallo;
var parametro = operazione.Utensile.ParametroUtensile as ParametroUtensileTornitura;
if (parametro == null)
{
return;
}
var profPassata = parametro.ProfonditaPassata;
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraSfacciaturaSgrossatura:
{
TurnProgrammingHelper.GetFaceRoughing(moveCollection, DiametroMax, DiametroMin, InizioZ, zStart, profPassata, 1);
}
break;
case LavorazioniEnumOperazioni.TornituraSfacciaturaFinitura:
{
TurnProgrammingHelper.GetFaceFinishing(moveCollection, DiametroMax, DiametroMin, InizioZ, 1);
}
break;
default:
Trace.WriteLine("Tornitura.CreateSpecificProgram");
break;
}
foreach (var action in moveCollection)
{
programPhase.AggiungiAzioneMovimento(action);
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var parametro = operazione.Utensile.ParametroUtensile as ParametroUtensileTornituraScanalatura;
var utensile = operazione.Utensile as UtensileScanalatura;
if (parametro == null || utensile == null)
{
return;
}
var larghUtensile = utensile.LarghezzaUtensile;
var larghPassata = parametro.LarghezzaPassata;
var step = parametro.Step;
var moveCollection = new MoveActionCollection();
if (larghUtensile > Larghezza)
{
return;
}
for (int i = 0; i < NumeroGole; i++)
{
switch (ScanalaturaType)
{
case GrooveDirection.Extern:
{
var stepGole = i * DistanzaGole;
var startZ = StartZ - stepGole;
var endZ = startZ + Larghezza - larghUtensile;
var dMax = Math.Max(DiameterIniziale, DiameterFinale);
var dMin = Math.Min(DiameterIniziale, DiameterFinale);
var dIni = dMax;
var dFin = dMin;
//var effectiveStart = startZ + larghUtensile;
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraScanalaturaSgrossatura:
{
TurnProgrammingHelper.GetSgrossaturaGolaEsterna(moveCollection, dIni,
dFin, startZ, endZ, step,
larghPassata, 0);
}
break;
case LavorazioniEnumOperazioni.TornituraScanalaturaFinitura:
{
TurnProgrammingHelper.GetFinituraGolaEsternaInterna(moveCollection, DiameterIniziale, DiameterFinale, startZ, endZ, 0, ExtraCorsa);
}
break;
}
} break;
case GrooveDirection.Intern:
{
var stepGole = i * DistanzaGole;
var startZ = StartZ - stepGole;
var endZ = startZ + Larghezza - larghUtensile;
var dMax = Math.Max(DiameterIniziale, DiameterFinale);
var dMin = Math.Min(DiameterIniziale, DiameterFinale);
var dIni = dMin;
var dFin = dMax;
//var effectiveStart = startZ + larghUtensile;
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraScanalaturaSgrossatura:
{
TurnProgrammingHelper.GetSgrossaturaGolaInterna(moveCollection, dIni,
dFin, startZ, endZ, step,
larghPassata, 0);
}
break;
case LavorazioniEnumOperazioni.TornituraScanalaturaFinitura:
{
TurnProgrammingHelper.GetFinituraGolaEsternaInterna(moveCollection, DiameterIniziale, DiameterFinale, startZ, endZ, 0, ExtraCorsa);
}
break;
}
} break;
case GrooveDirection.Face:
{
var stepGole = i * DistanzaGole;
var startZ = StartZ;
var endZ = startZ - Larghezza;
var dMax = Math.Max(DiameterIniziale, DiameterFinale);
var dMin = Math.Min(DiameterIniziale, DiameterFinale);
var diaIni = dMin + stepGole;
var diaFin = dMax + stepGole - larghUtensile;
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.TornituraScanalaturaSgrossatura:
{
TurnProgrammingHelper.GetSgrossaturaGolaFrontale(moveCollection, diaIni,
diaFin, startZ, endZ, step,
larghPassata, 0);
}
break;
case LavorazioniEnumOperazioni.TornituraScanalaturaFinitura:
{
TurnProgrammingHelper.GetFinituraGolaFrontale(moveCollection, diaIni, diaFin, startZ, endZ, ExtraCorsa, 0);
}
break;
}
} break;
}
}
foreach (var variable in moveCollection)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var diametrable = operazione.Utensile as IDiametrable;
var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
if (diametrable == null)
{
return;
}
var diaFresa = diametrable.Diametro;
double profPassata = 0;
double larghezzaPassata = 0;
if (parametro != null)
{
profPassata = parametro.GetProfonditaPassata();
larghezzaPassata = parametro.GetLarghezzaPassata();
}
var moveCollection = new MoveActionCollection();
var workProfile = GetProfile();
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.Sgrossatura:
{
var sovraXy = SovrametalloFinituraProfilo;
if (!Finitura.Abilitata)
{
sovraXy = 0;
}
MillProgrammingHelper.GetInternRoughing(moveCollection, workProfile, ProfonditaLavorazione,
profPassata, larghezzaPassata, diaFresa, ExtraCorsa,
InizioLavorazioneZ, SicurezzaZ,
sovraXy, SovrametalloFinituraZ);
} break;
case LavorazioniEnumOperazioni.Finitura:
{
MillProgrammingHelper.GetInternFinish(moveCollection, workProfile, ProfonditaLavorazione, profPassata, diaFresa, ExtraCorsa, FinishWithCompensation, InizioLavorazioneZ, SicurezzaZ);
} break;
case LavorazioniEnumOperazioni.Smussatura:
{
MillProgrammingHelper.GetInternChamfer(moveCollection, workProfile, ProfonditaFresaSmussatura,
diaFresa, ExtraCorsa, ChamferWithCompensation,
InizioLavorazioneZ, SicurezzaZ);
} break;
default:
{
Debug.Fail("FresaturaCava.GetOperationProgram");
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var diaExt = MaschiaturaSelezionata.DiametroMetrico;
var passo = MaschiaturaSelezionata.Passo;
var diaMin = diaExt - passo;
var zIni = ZIniziale + passo * 3;
var zEnd = ZIniziale - LunghezzaFiletto;
var delta = diaExt - diaMin;
if (NumeroPassate <= 0)
{
NumeroPassate = 1;
}
var step = delta / NumeroPassate;
var currentX = diaExt;
var moveCollection = new MoveActionCollection();
// Qui dovrebbe già essere impostato i parametri di velocità, ora pero faccio override avanzamento per lavoro
ParametroVelocita p;
if (programPhase.FeedDictionary.TryGetValue(MoveType.Work, out p))
{
p.ModoAvanzamento = VelocitaType.Sync;
p.ValoreFeed = passo;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, zIni, diaExt + ExtraCorsa, 0);
var c = 0;
while (currentX > diaMin)
{
c++;
currentX -= step;
if (currentX <= diaMin)
{
currentX = diaMin;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, null, currentX, 0);
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, zEnd, null, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, null, diaExt, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, zIni, null, 0);
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, zIni, diaExt + ExtraCorsa, 0);
foreach (var variable in moveCollection)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
private static bool SpiralMovementV2(MoveActionCollection programPhase, ref SpiralMoveEnum moveEnum, ref double tempX, ref double tempY, double up, double down, double sx, double dx, double larghPassataX, double larghezzaPassataY, ref int counterX, ref int counterY, int nRighe, int nColonne, int minCounter, double raggioFresa)
{
switch (moveEnum)
{
/*
* teoria v2:
*
* dopo che ho fatto la divisione in celle ( come solito )
* ho lo scarto nella parte dx e down ,
*
* considero di partire da alto a dx
* mi serve convenzione..
*
* per convenzione punto finale è punto "teorico" ovvero punto arrivo se non ci fosse raggio.
*
* in modo che òa coordinata che non cambia si apposto per il prossimo movimento
*/
case SpiralMoveEnum.ToDown:
{
var nextY = up - (counterY * larghezzaPassataY) - raggioFresa;
var delta = tempY - nextY;
var yFinale = tempY;
var xFinale = tempX;
if (Math.Abs(delta) < raggioFresa * 2)
{
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xFinale, yFinale - raggioFresa, null);
return(false);
}
yFinale = tempY = nextY;
var startArc = new Point2D {
X = xFinale, Y = yFinale + raggioFresa
};
var endArc = new Point2D {
X = xFinale - raggioFresa, Y = yFinale
};
var center = new Point2D {
X = endArc.X, Y = startArc.Y
};
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, startArc.X, startArc.Y, null);
programPhase.AddArcMove(AxisAbilited.Xy, endArc.X, endArc.Y, null, raggioFresa, true, center);
moveEnum = SpiralMoveEnum.ToLeft;
counterX--;
} break;
case SpiralMoveEnum.ToLeft:
{
var passi = nColonne - counterX;
var nextX = sx + (passi * larghPassataX) - raggioFresa;
var delta = tempX - nextX;
var yFinale = tempY;
var xFinale = tempX;
if (Math.Abs(delta) < raggioFresa * 2)
{
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xFinale - raggioFresa, yFinale, null);
return(false);
}
xFinale = tempX = nextX;
var startArc = new Point2D {
X = xFinale + raggioFresa, Y = yFinale
};
var endArc = new Point2D {
X = xFinale, Y = yFinale + raggioFresa
};
var center = new Point2D {
X = startArc.X, Y = endArc.Y
};
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, startArc.X, startArc.Y, null);
programPhase.AddArcMove(AxisAbilited.Xy, endArc.X, endArc.Y, null, raggioFresa, true, center);
moveEnum = SpiralMoveEnum.ToUp;
counterY--;
} break;
case SpiralMoveEnum.ToUp:
{
var passi = nRighe - counterY;
var nextY = up - (passi * larghezzaPassataY) + raggioFresa;
var delta = tempY - nextY;
var yFinale = tempY;
var xFinale = tempX;
if (Math.Abs(delta) < raggioFresa * 2)
{
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xFinale, yFinale + raggioFresa, null);
return(false);
}
yFinale = tempY = nextY;
var startArc = new Point2D {
X = xFinale, Y = yFinale - raggioFresa
};
var endArc = new Point2D {
X = xFinale + raggioFresa, Y = yFinale
};
var center = new Point2D {
X = endArc.X, Y = startArc.Y
};
/*
* devo controllare che la distanza che devo coprire sia maggiore del raggio fresa
*/
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, startArc.X, startArc.Y, null);
programPhase.AddArcMove(AxisAbilited.Xy, endArc.X, endArc.Y, null, raggioFresa, true, center);
moveEnum = SpiralMoveEnum.ToRight;
// counterX--;
} break;
case SpiralMoveEnum.ToRight:
{
var nextX = sx + (counterX * larghPassataX) + raggioFresa;
var delta = tempX - nextX;
var xFinale = tempX;
var yFinale = tempY;
if (Math.Abs(delta) < raggioFresa * 2)
{
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xFinale + raggioFresa, yFinale, null);
return(false);
}
xFinale = tempX = nextX;
var startArc = new Point2D {
X = xFinale - raggioFresa, Y = yFinale
};
var endArc = new Point2D {
X = xFinale, Y = yFinale - raggioFresa
};
var center = new Point2D {
X = startArc.X, Y = endArc.Y
};
programPhase.AddLinearMove(MoveType.Work, AxisAbilited.Xy, startArc.X, startArc.Y, null);
programPhase.AddArcMove(AxisAbilited.Xy, endArc.X, endArc.Y, null, raggioFresa, true, center);
moveEnum = SpiralMoveEnum.ToDown;
} break;
default:
throw new NotImplementedException();
}
/*
* in pratica deve restituirmi linea dritta e movimento angolare
*/
return(true);
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
/*
* utensile e parametro lo prendo all'interno del cambio switch..
*/
var fresa = operazione.Utensile as FresaCandela;
var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
if (fresa == null || parametro == null)
{
throw new NullReferenceException();
}
if (PatternDrilling == null)
{
return;
}
var diameter = DiametroMetricoFinale;
var pntList = PatternDrilling.GetPointList();
if (pntList == null || pntList.Count <= 0)
{
return;
}
var diaFresa = fresa.Diametro;
var moveCollection = new MoveActionCollection();
var workUp = InizioLavorazioneZ;
var workDown = InizioLavorazioneZ - ProfonditaLavorazione;
foreach (var point2D in pntList)
{
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.Smussatura:
{
var profile = Profile2D.CreateCircle(DiametroMetricoFinale / 2, point2D);
MillProgrammingHelper.GetInternChamfer(moveCollection, profile, ProfonditaSvasatura, diaFresa, 0, false, InizioLavorazioneZ, SicurezzaZ);
} break;
case LavorazioniEnumOperazioni.FresaturaFilettare:
{
var helicalRadius = (diameter - diaFresa) / 2;
if (FilettaturaSinistra && !FilettaturaEsterna)
{
//MillProgrammingHelper.GetInternThreadSx(moveCollection, );
MillProgrammingHelper.GetInternThreadSx(moveCollection, workUp, workDown, SicurezzaZ, point2D, PassoMetrico, DiametroMetricoFinale / 2, true);
}
else if (!FilettaturaSinistra && !FilettaturaEsterna)
{
MillProgrammingHelper.GetInternThreadDx(moveCollection, workUp, workDown, SicurezzaZ, point2D, PassoMetrico, DiametroMetricoFinale / 2, true);
}
else if (!FilettaturaSinistra && FilettaturaEsterna)
{
var extracorsa = diaFresa / 2 + ExtraCorsa;
MillProgrammingHelper.GetExternThreadDx(moveCollection, workUp, workDown, SicurezzaZ, point2D, PassoMetrico, DiametroMetricoFinale / 2, true, extracorsa);
}
else if (FilettaturaSinistra && FilettaturaEsterna)
{
var extracorsa = diaFresa / 2 + ExtraCorsa;
MillProgrammingHelper.GetExternThreadSx(moveCollection, workUp, workDown, SicurezzaZ, point2D, PassoMetrico, DiametroMetricoFinale / 2, true, extracorsa);
}
}
break;
default:
throw new Exception("FresaturaFilettatura.CreateSpecificProgram");
break;
}
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
internal static void GetSgrossaturaEsterna(ProgramOperation programOperation, MoveActionCollection moveCollection, Profile2D profile2D, double profPassata, double avvicinamento, double stacco)
{
/*
* assumo anche che nel profilo non ci siano tasche..
*/
var diaIniziale = GetRoughIniDiameter(profile2D, Tornitura.TipoTornitura.Esterna);
var diaFinale = GetRoughFinDiameter(profile2D, Tornitura.TipoTornitura.Esterna);
var zMin = GetMinZ(profile2D);
var zIniziale = GetMaxZ(profile2D) + avvicinamento;
var r = stacco;
var currentDia = diaIniziale;
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, zIniziale, currentDia, 0);
while (currentDia > diaFinale)
{
currentDia -= profPassata;
if (currentDia <= diaFinale)
{
currentDia = diaFinale;
}
var scanIniPoint = new Point2D(zIniziale, currentDia);
var scanEndPoint = new Point2D(zMin, currentDia);
var scanLine = new Line2D()
{
Start = scanIniPoint, End = scanEndPoint
};
var intersectPoint = FindIntersectionPoint(profile2D, scanLine);
if (intersectPoint == null)
{
break;
}
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, null, currentDia, 0);
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xyz, intersectPoint.X, null, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xyz, zIniziale, currentDia + avvicinamento,
0);
//var line = new Line2D() {Start = iniPoint, End = intersectPoint};
// poi devo fare stacco , ritorno a z e incremento diametro.
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var parametro = operazione.GetParametro <ParametroFresaSpianare>();
if (parametro == null)
{
throw new NullReferenceException();
}
var larghezzaPassata = parametro.GetLarghezzaPassata();
var profPassata = parametro.GetProfonditaPassata();
var diaFresa = parametro.DiametroMinimoFresa;
diaFresa -= parametro.GetRaggioInserto() * 2;
var diaIngombroFresa = parametro.DiametroIngombroFresa;
var sovraMetallo = Sovrametallo - SovrametalloPerFinitura;
var ottimizza = false; // per ora non lo lascio modificare da utente
var passataMinimaPercentuale = 20.0d; // -- ,, valori sballati potrebbero causare bug non previsti
var moveCollection = new MoveActionCollection();
var centerPoint = GetCenterPoint();
switch ((LavorazioniEnumOperazioni)operazione.OperationType)
{
case LavorazioniEnumOperazioni.FresaturaSpianaturaSgrossatura:
{
var zLavoro = LivelloZ + SovrametalloPerFinitura;
switch (ModoSgrossatura)
{
case SpiantaturaMetodologia.Tradizionale:
{
OneDirectionFaceMilling(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, ExtraCorsa);
} break;
case SpiantaturaMetodologia.Spirale:
{
SpiralFaceMillingV2(moveCollection, centerPoint.X, centerPoint.Y, Larghezza, Altezza, larghezzaPassata, diaFresa, diaIngombroFresa, sovraMetallo, profPassata, zLavoro, SicurezzaZ, ExtraCorsa, ottimizza, passataMinimaPercentuale);
} break;
}
} break;
case LavorazioniEnumOperazioni.FresaturaSpianaturaFinitura:
{
switch (ModoFinitura)
{
case SpiantaturaMetodologia.Tradizionale:
{
OneDirectionFaceMilling(moveCollection,
centerPoint.X, centerPoint.Y,
Larghezza, Altezza, larghezzaPassata,
diaFresa,
diaIngombroFresa,
SovrametalloPerFinitura,
profPassata,
LivelloZ,
SicurezzaZ,
ExtraCorsa
);
} break;
case SpiantaturaMetodologia.Spirale:
{
// richiamo stesso procedimento , metto solo profondita == sovrametallo
// magari fare spiarale singolo in un metodo e richiamarla con sgrossatura più volte
SpiralFaceMillingV2(moveCollection,
centerPoint.X, centerPoint.Y,
Larghezza, Altezza,
larghezzaPassata,
diaFresa,
diaIngombroFresa,
SovrametalloPerFinitura,
profPassata,
LivelloZ, SicurezzaZ, ExtraCorsa,
ottimizza,
passataMinimaPercentuale);
} break;
}
} break;
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
private static void ElaborateCycle(MoveActionCollection move, MacroForaturaAzione macro)
{
var enumOperazioniForatura = macro.TipologiaLavorazione;
var modalitaForatura = macro.ModalitaForatura;
switch (enumOperazioniForatura)
{
case LavorazioniEnumOperazioni.ForaturaPunta:
{
switch (modalitaForatura)
{
case Lavorazioni.Foratura.ModalitaForatura.StepScaricoTruciolo:
{
if (macro.Step == 0)
{
macro.Step = -macro.EndZ - macro.StartZ;
}
var currentZ = macro.StartZ;
while (currentZ > macro.EndZ)
{
currentZ -= macro.Step;
if (currentZ < macro.EndZ)
{
currentZ = macro.EndZ;
}
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, currentZ);
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, macro.StartZ);
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, currentZ);
}
} break;
default:
case Lavorazioni.Foratura.ModalitaForatura.StepSenzaScaricoTruciolo:
case Lavorazioni.Foratura.ModalitaForatura.Semplice:
{
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.EndZ);
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, macro.SicurezzaZ);
} break;
}
} break;
case LavorazioniEnumOperazioni.ForaturaMaschiaturaDx:
case LavorazioniEnumOperazioni.ForaturaMaschiaturaSx:
{
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.EndZ);
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.SicurezzaZ);
} break;
case LavorazioniEnumOperazioni.ForaturaAlesatore:
{
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.EndZ);
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.SicurezzaZ);
} break;
/*
* In questi casi l'utensile va giu in lavoro e ritorna a punto iniziale in rapido
*/
case LavorazioniEnumOperazioni.ForaturaBareno:
case LavorazioniEnumOperazioni.ForaturaLamatore:
case LavorazioniEnumOperazioni.ForaturaCentrino:
case LavorazioniEnumOperazioni.ForaturaSmusso:
{
move.AddLinearMove(MoveType.Work, AxisAbilited.Z, null, null, macro.EndZ);
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, macro.SicurezzaZ);
} break;
default:
throw new NotImplementedException("DrillBaseClass.ElaborateCycle");
}
}
/// <summary>
/// Creo Programma per lavorazioni di foratura.
/// Raccoglie dati per creare macro specifiche.
/// Per allargatura foro nella barenatura e lamatura faccio programma ad hoc
/// </summary>
/// <param name="programPhase"></param>
/// <param name="operazione"></param>
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
if (operazione.OperationType == LavorazioniEnumOperazioni.AllargaturaBareno)
{
ElaborateAllargaturaBareno(programPhase, operazione);
return;
}
var preference = Singleton.Preference.GetPreference(Singleton.Instance.MeasureUnit);
var distanzaSicurezza = preference.DistanzaSicurezzaCicliForatura;
var macro = new MacroForaturaAzione(programPhase)
{
PuntiForatura = GetDrillPointList(),
SicurezzaZ = SicurezzaZ,
StartZ = InizioZ,
TipologiaLavorazione = operazione.OperationType,
CodiceR = InizioZ + distanzaSicurezza,
};
macro.ParametriTaglio = new ParametroVelocita();
ParametroVelocita parametroVelocita;
if (programPhase.FeedDictionary.TryGetValue(MoveType.Work, out parametroVelocita))
{
macro.ParametriTaglio = parametroVelocita;
}
/*
* il punto r è la distanza fra z di sicurezza e z iniziale, - distanza di avvicinamento.. tipo 2mm
*/
// macro)
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.ForaturaAlesatore:
{
var alesatura = operazione.Lavorazione as IAlesatoreAble;
if (alesatura == null)
{
throw new NullReferenceException();
}
macro.EndZ = InizioZ - alesatura.ProfonditaAlesatore;
} break;
case LavorazioniEnumOperazioni.ForaturaBareno:
{
var opMaschiatura = operazione.Lavorazione as IBarenoAble;
if (opMaschiatura == null)
{
throw new NullReferenceException();
}
macro.EndZ = InizioZ - opMaschiatura.ProfonditaBareno;
} break;
case LavorazioniEnumOperazioni.ForaturaLamatore:
{
var opMaschiatura = operazione.Lavorazione as ILamaturaAble;
if (opMaschiatura == null)
{
throw new NullReferenceException();
}
macro.EndZ = InizioZ - opMaschiatura.ProfonditaLamatura;
macro.Sosta = 500;
} break;
case LavorazioniEnumOperazioni.ForaturaMaschiaturaDx:
{
var opMaschiatura = operazione.Lavorazione as IMaschiaturaAble;
if (opMaschiatura == null)
{
throw new NullReferenceException();
}
macro.Sosta = 500;
macro.EndZ = InizioZ - opMaschiatura.ProfonditaMaschiatura;
} break;
case LavorazioniEnumOperazioni.ForaturaCentrino:
{
var opCentrinable = operazione.Lavorazione as ICentrinoAble;
if (opCentrinable == null)
{
throw new NullReferenceException();
}
macro.EndZ = InizioZ - ProfonditaCentrino;
} break;
case LavorazioniEnumOperazioni.ForaturaSmusso:
{
var opSvasatura = operazione.Lavorazione as ISvasaturaAble;
if (opSvasatura == null)
{
throw new NullReferenceException();
}
macro.EndZ = InizioZ - ProfonditaSvasatura;
macro.Sosta = 500;
} break;
case LavorazioniEnumOperazioni.ForaturaPunta:
{
var opForatura = operazione.Lavorazione as IForaturaAble;
if (opForatura == null)
{
throw new NullReferenceException();
}
macro.ModalitaForatura = ModalitaForatura;
macro.EndZ = InizioZ - ProfonditaForatura;
/* Qui mi serve step, il parametro deve essere parametro punta,
* Nel caso non lo fosse non scoppia niente.
*/
var parametro = operazione.GetParametro <ParametroPunta>();
if (parametro != null)
{
macro.Step = parametro.Step;
}
} break;
}
/*
* Ora devo " sviluppare" l'azione macro per avere un'anteprima corretta e un corretto tempo macchina..
*/
var move = new MoveActionCollection();
var pntList = macro.PuntiForatura;
foreach (var point2D in pntList)
{
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, point2D.X, point2D.Y, null);
move.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, macro.SicurezzaZ);
ElaborateCycle(move, macro);
/*
* fare r del ciclo.
*/
move.AddLinearMove(MoveType.SecureRapidFeed, AxisAbilited.Z, null, null, macro.SicurezzaZ);
}
macro.MoveActionCollection = move;
foreach (var variable in macro.MoveActionCollection)
{
programPhase.SettaValoreAvanzamento(variable);
}
}
private void ElaborateAllargaturaBareno(ProgramOperation programPhase, Operazione operazione)
{
var opBarenatura = operazione.Lavorazione as IBarenoAble;
if (opBarenatura == null)
{
throw new NullReferenceException();
}
var pntListBar = GetDrillPointList();
var moveCollection = new MoveActionCollection();
var iniZ = InizioZ;
var endZ = InizioZ - opBarenatura.ProfonditaBareno;
var fresa = operazione.Utensile as FresaCandela;
var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
var larghezzaPassata = parametro.GetLarghezzaPassata();
var profPassata = parametro.GetProfonditaPassata();
var diaAllargatura = opBarenatura.DiametroBarenatura - opBarenatura.MaterialePerFinitura;
if (InizioZ <= endZ)
{
return;
}
if (fresa.Diametro > diaAllargatura)
{
return;
}
foreach (var point2D in pntListBar)
{
// Semplice)
if (opBarenatura.ModalitaAllargatura == 0)
{
var profile = Profile2D.CreateCircle(diaAllargatura / 2, point2D);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, point2D.X,
point2D.Y, null, null);
MillProgrammingHelper.GetInternRoughing(moveCollection, profile, opBarenatura.ProfonditaBareno,
profPassata, larghezzaPassata, fresa.Diametro, 0, InizioZ, SicurezzaZ, 0, 0);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, point2D.X,
point2D.Y, null, null);
}
// Interpolazione
else if (opBarenatura.ModalitaAllargatura == 1)
{
MillProgrammingHelper.GetRoughHelicalInterpolation(moveCollection, InizioZ, endZ, SicurezzaZ, point2D,
diaAllargatura, fresa.Diametro, profPassata, larghezzaPassata);
}
}
foreach (var a in moveCollection)
{
programPhase.AggiungiAzioneMovimento(a);
}
}
//internal override ProgramPhase GetOperationProgram(Operazione operazione)
//{
// var program = new ProgramPhase(SicurezzaZ);
// var toolChange = new ChangeToolAction(program, operazione);
// program.ActiveAsseC(true);
// var fresa = operazione.Utensile as FresaCandela;
// var parametro = operazione.Utensile.ParametroUtensile as ParametroFresaCandela;
// if (fresa == null || parametro == null)
// throw new NullReferenceException();
// var diaFresa = fresa.DiametroFresa;
// var larghezzaPassata = parametro.GetLarghezzaPassata();
// var profPassata = parametro.GetProfonditaPassata();
// var feed = parametro.GetFeed(FeedType.ASync);
// var plungeFeed = parametro.AvanzamentoAsincronoPiantata.Value.Value;
// var secureFeed = 1;
// var extraCorsa = 1;
// var moveCollection = new MoveActionCollection();
// if (feed <= 0)
// return null;
// var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, secureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// {MoveType.PlungeFeed, plungeFeed}
// };
// program.SetFeedDictionary(feedDictionary);
// switch ((LavorazioniEnumOperazioni)operazione.OperationType)
// {
// default:
// {
// EngravingText(moveCollection, GetTextProfiles(), ProfonditaLavorazione, SicurezzaZ, InizioLavorazioneZ);
// } break;
// }
// var mm = base.GetFinalProgram(moveCollection);
// foreach (var variable in mm)
// {
// program.AddMoveAction(variable);
// }
// program.ActiveAsseC(false);
// return program;
//}
private static void EngravingText(MoveActionCollection moveCollection, IEnumerable <Profile2D> profiles, double ProfonditaLavorazione, double SicurezzaZ, double InizioLavorazioneZ)
{
if (CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(SicurezzaZ, InizioLavorazioneZ - ProfonditaLavorazione),
})
)
{
return;
}
if (profiles == null || profiles.Count() == 0)
{
return;
}
var zLavoro = InizioLavorazioneZ - ProfonditaLavorazione;
var firstElement = profiles.First().Source.FirstOrDefault();
if (firstElement == null)
{
return;
}
var attacPoint = firstElement.GetFirstPnt();
if (attacPoint == null)
{
return;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, attacPoint.X, attacPoint.Y, null);
foreach (var profile2D in profiles)
{
var element = profile2D.Source;
var p = Geometry.Entity.Profile2D.ParseArcIn2DProfile(profile2D);
var source = p.Source;
// arc parsingg
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, SicurezzaZ);
if (source[0] is Line2D)
{
var firstMove = ((Line2D)source[0]).Start;
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, firstMove.X, firstMove.Y, null);
moveCollection.AddLinearMove(MoveType.PlungeFeed, AxisAbilited.Z, null, null, zLavoro);
}
foreach (var entity2D in source)
{
if (entity2D is Line2D)
{
var line = entity2D as Line2D;
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xy, line.End.X, line.End.Y, null);
}
else if (entity2D is Arc2D)
{
// implementare archi
var arc = entity2D as Arc2D;
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xy, arc.Start.X, arc.Start.Y, null);
moveCollection.AddArcMove(AxisAbilited.Xy, arc.End.X, arc.End.Y, null, arc.Radius, arc.ClockWise, arc.Center);
}
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, SicurezzaZ);
}
}
internal static void GetRoughingTurnProgram(ProgramOperation programOperation, MoveActionCollection moveCollection, Profile2D profile2D, double profPassata, double avvicinamento, double stacco, Tornitura.TipoTornitura tipoTornitura, bool useMacro, double sovraX, double sovraZ)
{
// assumo che sia diametro esterno.
if (CheckValueHelper.GreatherThanZero(new[] { profPassata, }))
{
return;
}
if (profile2D == null)
{
return;
}
if (useMacro)
{
var turnMacro = new MacroLongitudinalTurningAction(programOperation)
{
SovraMetalloX = sovraX,
SovraMetalloZ = sovraZ,
Profile = profile2D,
ProfonditaPassata = profPassata,
Distacco = stacco,
TipologiaLavorazione = tipoTornitura,
};
}
switch (tipoTornitura)
{
case Tornitura.TipoTornitura.Esterna:
{
GetSgrossaturaEsterna(programOperation, moveCollection, profile2D, profPassata, avvicinamento, stacco);
} break;
case Tornitura.TipoTornitura.Interna:
{
GetSgrossaturaInterna(moveCollection, profile2D, profPassata, avvicinamento, stacco, useMacro);
} break;
}
}
protected override void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione)
{
var dia = operazione.Utensile as IDiametrable;
if (dia == null)
{
return;
}
var diaTool = dia.Diametro;
var moveCollection = new MoveActionCollection();
switch (operazione.OperationType)
{
case LavorazioniEnumOperazioni.Sgrossatura:
{
var par = operazione.GetParametro <ParametroFresaCandela>();
if (par == null)
{
throw new NullReferenceException();
}
var profPassat = par.GetProfonditaPassata();
var larghPassat = par.GetLarghezzaPassata();
ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaLavorazione,
profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, ExtraCorsa, InizioLavorazioneZ);
} break;
case LavorazioniEnumOperazioni.Finitura:
{
var par = operazione.GetParametro <ParametroFresaCandela>();
if (par == null)
{
throw new NullReferenceException();
}
var profPassat = par.GetProfonditaPassata();
var larghPassat = par.GetLarghezzaPassata();
/*
* Per finitura assumo sovrametallo minore della larghezza passata
*/
var compensationType = 0;
if (FinishWithCompensation)
{
compensationType = 2;
}
ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, larghPassat, ProfonditaLavorazione,
profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, ExtraCorsa, InizioLavorazioneZ, compensationType);
} break;
case LavorazioniEnumOperazioni.Smussatura:
{
var profPassat = ProfonditaFresaSmussatura;
var larghPassat = diaTool / 2;
/*
* Per finitura assumo sovrametallo minore della larghezza passata
*/
ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, larghPassat, ProfonditaFresaSmussatura,
profPassat, larghPassat, diaTool, SicurezzaZ, ExtraCorsa, InizioLavorazioneZ);
//ProcessChamferSideLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaFresaSmussatura, diaTool, SicurezzaZ, ExtraCorsa, InizioLavorazioneZ);
} break;
default:
throw new NotImplementedException();
}
var mm = base.GetFinalProgram(moveCollection);
foreach (var variable in mm)
{
programPhase.AggiungiAzioneMovimento(variable);
}
}
/// <summary>
/// Calcola percorso di spianatura a spirale
/// </summary>
/// <param name="programPhase"></param>
/// <param name="offsetX"></param>
/// <param name="offsetY"></param>
/// <param name="larghezza"></param>
/// <param name="altezza"></param>
/// <param name="larghPassata"></param>
/// <param name="diaFresaEffettivo">Diametro Effettivo Fresa</param>
/// <param name="diaFresaIngombro">Diametro Ingombro Fressa</param>
/// <param name="sovraMetallo"></param>
/// <param name="profPassata"></param>
/// <param name="zFinale"></param>
/// <param name="zSicurezza">Z Sicurezza</param>
/// <param name="extraCorsaSicurezza"></param>
/// <param name="ottimizzaPassate">Con true calcolo nuova larghezza di passata minima</param>
/// <param name="passataMinimaPercentuale">Passata Minima Percentuale</param>
private static void SpiralFaceMillingV2(MoveActionCollection programPhase,
double offsetX, double offsetY,
double larghezza, double altezza,
double larghPassata, double diaFresaEffettivo,
double diaFresaIngombro,
double sovraMetallo, double profPassata,
double zFinale, double zSicurezza,
double extraCorsaSicurezza, bool ottimizzaPassate, double passataMinimaPercentuale)
{
/*
* todo : considerare anche raggio inserto--
*/
/*
* é meglio se avanzamenti li registro qui..
*/
if (CheckValueHelper.GreatherOrEqualZero(new[] { sovraMetallo, extraCorsaSicurezza }) ||
CheckValueHelper.GreatherThanZero(new[] { larghezza, altezza, larghPassata, diaFresaEffettivo, profPassata, diaFresaIngombro }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(zSicurezza, zFinale + sovraMetallo),
new KeyValuePair <double, double>(diaFresaEffettivo, larghPassata),
})
)
{
return;
}
/*
* Per creare spianatura divido l'area di lavoro in griglia a quadrati con lato == larghezzaPassata
*/
var larghezzaPassataX = larghPassata;
var larghezzaPassataY = larghPassata;
var nColonneTeoriche = larghezza / larghPassata;
var nRigheTeoriche = altezza / larghPassata;
var nColonne = (int)Math.Floor(nColonneTeoriche);
var nRighe = (int)Math.Floor(nRigheTeoriche);
/*
* devo per forza cambiare larghPassata, mantenendo il valore compreso fra un min e max.
*
* una volta che ho questo valore , proseguo per il mio ciclo come solito..
*
*/
if (ottimizzaPassate)
{
var passataMin = (larghPassata * passataMinimaPercentuale) / 100;
var restoX = larghezza % larghezzaPassataX;
var restoY = altezza % larghezzaPassataY;
if (restoX < passataMin)
{
// modifico larghezza passata X
larghezzaPassataX = larghezza / nColonne;
nColonne--;
}
if (restoY < passataMin)
{
// modifico larghezza passata Y
larghezzaPassataY = altezza / nRighe;
// dimuisco numero di righe,
nRighe--;
}
}
/*
* Raggio della fresa, sara il raggio che usero durante gli angoli nella spianatura
*/
var raggioEffettivoFresa = diaFresaEffettivo / 2;
/*
* todo: gestire anche diversi direzioni lavorazione e quindi punti entrata
*/
var sx = offsetX - larghezza / 2;
var dx = offsetX + larghezza / 2;
var down = offsetY - altezza / 2;
var up = offsetY + altezza / 2;
/*
* in pratica per trovare punto arrivo moltiplico la larghezza di Passata per le celle delle griglia rimaste..
*/
var zCurrent = zFinale + sovraMetallo;
// Itero per tutte le passate in Z
while (zCurrent > zFinale)
{
zCurrent -= profPassata;
if (zCurrent < zFinale)
{
zCurrent = zFinale;
}
// rimuovere
var minElement = (int)Math.Min(nColonne, nRighe);
/*
* 1.1 ) Punto attacco XY
*
* Il punto di inizio in alto a dx , tiene presente dell'ingombro massimo fresa e diametro effettivo di lavorazione + extraCorsaSicurezza
*/
var raggioIngombro = diaFresaIngombro / 2;
var puntoInizio = new Point2D
{
X = sx + (nColonne) * larghezzaPassataX,
Y = up + raggioIngombro + extraCorsaSicurezza
};
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, puntoInizio.X, puntoInizio.Y, null);
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, zSicurezza);
// 1.2 ) Andare a z Corrent
programPhase.AddLinearMove(MoveType.SecureRapidFeed, AxisAbilited.Z, null, null, zCurrent);
// 1.3 ) Punto avvicinamento diametro effettivo fresa
var puntoAvvi = new Point2D
{
X = puntoInizio.X,
Y = up + raggioEffettivoFresa
};
programPhase.AddLinearMove(MoveType.PlungeFeed, AxisAbilited.Xy, puntoAvvi.X, puntoAvvi.Y, null);
// 1.4) Interpolazione per fare entrata
var puntoFinaleArcoEntrata = new Point2D
{
X = sx + (nColonne * larghezzaPassataX) + raggioEffettivoFresa,
Y = up,
};
programPhase.AddArcMove(AxisAbilited.Xy, puntoFinaleArcoEntrata.X, puntoFinaleArcoEntrata.Y, null, raggioEffettivoFresa, true, new Point2D(puntoAvvi.X, up));
/*
* Ora magari vorrei cercare di cambiare ciclo in qualcosa di più chiaro e gestibile..
*
* qui a posso usare metodi aux..
*
* poso
*/
// 1.5) Lavorazione fino a termine materiale
var continueCycle = true;
var moveEnum = SpiralMoveEnum.ToDown;
var startMove = moveEnum;
var tempX = puntoFinaleArcoEntrata.X;
var tempY = puntoFinaleArcoEntrata.Y;
// cambiare se cambia senso direzione
// counterCelleY++;
var tempConterColonne = nColonne;
var tempCounterRighe = nRighe;
while (continueCycle)
{
continueCycle = SpiralMovementV2(programPhase, ref moveEnum, ref tempX, ref tempY, up, down, sx, dx, larghezzaPassataX, larghezzaPassataY, ref tempConterColonne, ref tempCounterRighe, nRighe, nColonne, minElement, raggioEffettivoFresa);
// anche questo va cambiato se si decide di fare scegliere punto attacco
//if (moveEnum == SpiralMoveEnum.ToDown)
//{
// tempConterColonne--;
// tempCounterRighe--;
//}
}
// 1.6) Porto fresa a Z Sicurezza
programPhase.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, zSicurezza);
}
}
//internal override ProgramPhase GetOperationProgram(Operazione operazione)
//{
// /*
// * il richiamo degli utensili magari farlo e delle operazioni comuni magari farlo in astratto più a monte
// *
// */
// var program = new ProgramPhase(SicurezzaZ);
// // cambio utensile // se
// var toolChange = new ChangeToolAction(program, operazione);
// /*
// * potrei settare qui punto iniziale.. non vedo altre opzioni. rimane sempre una cosa da ricordarsi in più
// * >> more bugs..
// */
// program.ActiveAsseC(true);
// var secureFeed = 1;
// var extraCorsa = 1;
// var parametro = operazione.GetParametro<ParametroFresaCandela>();
// var feed = parametro.GetFeed(FeedType.ASync);
// if (feed <= 0)
// return null;
// var feedDictionary = new Dictionary<MoveType, double>
// {
// {MoveType.Rapid, 10000},
// {MoveType.SecureRapidFeed, secureFeed},
// {MoveType.Work, feed},
// {MoveType.Cw, feed},
// {MoveType.Ccw, feed},
// };
// program.SetFeedDictionary(feedDictionary);
// if (parametro == null)
// throw new NullReferenceException();
// var moveCollection = new MoveActionCollection();
// switch ((LavorazioniEnumOperazioni)operazione.OperationType)
// {
// case LavorazioniEnumOperazioni.Sgrossatura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// var profPassat = par.GetProfonditaPassata();
// var larghPassat = par.GetLarghezzaPassata();
// ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaLavorazione,
// profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// case LavorazioniEnumOperazioni.Finitura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// var profPassat = par.GetProfonditaPassata();
// var larghPassat = par.GetLarghezzaPassata();
// /*
// * Per finitura assumo sovrametallo minore della larghezza passata
// */
// ProcessRoughLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, larghPassat, ProfonditaLavorazione,
// profPassat, larghPassat, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// case LavorazioniEnumOperazioni.Smussatura:
// {
// var par = operazione.GetParametro<ParametroFresaCandela>();
// if (par == null)
// throw new NullReferenceException();
// /*
// * qui al posto della profondita lavorazione uso valore profondita fresa smussatura.
// */
// ProcessChamferSideLineMilling(moveCollection, PuntoInizialeX, PuntoInizialeY, OrientationAngle, Lunghezza, Sovrametallo, ProfonditaFresaSmussatura, par.DiametroFresa, SicurezzaZ, extraCorsa, InizioLavorazioneZ);
// } break;
// default:
// throw new NotImplementedException();
// }
// var mm = base.GetFinalProgram(moveCollection);
// foreach (var variable in mm)
// {
// program.AddMoveAction(variable);
// }
// program.ActiveAsseC(false);
// return program;
//}
private static void ProcessRoughLineMilling(MoveActionCollection moveCollection, double puntoInizialeX, double puntoInizialeY, double orientationAngle,
double lunghezza, double sovrametallo, double profonditaLavorazione, double profPassat, double larghPassat,
double diaFresa, double sicurezzaZ, double extraCorsa, double inizioLavorazioneZ, int isCncCompensated = 0)
{
if (CheckValueHelper.GreatherThanZero(new[] { profPassat, larghPassat, lunghezza, sovrametallo, profonditaLavorazione, diaFresa }) ||
CheckValueHelper.GreatherThan(new[]
{
new KeyValuePair <double, double>(sicurezzaZ, inizioLavorazioneZ),
})
)
{
return;
}
var currentZ = inizioLavorazioneZ;
var zFinale = currentZ - profonditaLavorazione;
var raggioFresa = diaFresa / 2;
var offset = raggioFresa;
if (isCncCompensated != 0)
{
offset = 0;
}
var xIniPoint = puntoInizialeX - extraCorsa - raggioFresa;
var xEndPoint = puntoInizialeX + extraCorsa + raggioFresa + lunghezza;
var yIniPoint = puntoInizialeY + sovrametallo + offset;
var yEndPoint = puntoInizialeY + offset;
CncCompensationState cncCompensationState = CncCompensationState.NoChange;
if (isCncCompensated == 1)
{
cncCompensationState = CncCompensationState.G41;
}
else if (isCncCompensated == 2)
{
cncCompensationState = CncCompensationState.G42;
}
var rotationMatrix = new Matrix3D();
rotationMatrix.RotateAt(new Quaternion(new Vector3D(0, 0, 1), orientationAngle), new System.Windows.Media.Media3D.Point3D(puntoInizialeX, puntoInizialeY, 0));
while (currentZ > zFinale)
{
currentZ -= profPassat;
if (currentZ < zFinale)
{
currentZ = zFinale;
}
var currentY = yIniPoint;
while (currentY > yEndPoint)
{
currentY -= larghPassat;
if (currentY < yEndPoint)
{
currentY = yEndPoint;
}
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Xy, xIniPoint, currentY, null, rotationMatrix, null, cncCompensationState);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, currentZ);
moveCollection.AddLinearMove(MoveType.Work, AxisAbilited.Xy, xEndPoint, currentY, null, rotationMatrix);
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ);
}
if (cncCompensationState == CncCompensationState.G41 || cncCompensationState == CncCompensationState.G42)
{
moveCollection.AddLinearMove(MoveType.Rapid, AxisAbilited.Z, null, null, sicurezzaZ, null, CncCompensationState.G40);
}
}
}