internal override ProgramOperation GetOperationProgram(Operazione operazione)
{
/*
* - init program
* - toolChange ( poi in fase di calcolo programma vedo se saltarlo o meno )
* - settaggio feed. ( vedere meglio)
*
* -- calcolo programma ( questo è l'unica parte diversa )
*
* - rototraslazione operazioni
*/
var preference = Singleton.Preference.GetPreference(MeasureUnit);
var program = new ProgramOperation(0);
ExtraCorsa = preference.TurningSecureDistance;
//RapidSecureFeed = preference.TurningRapidSecureFeedSync;
var changeToolAction = new CambiaUtensileAction(program, operazione);
var rapidFeed = FaseDiLavoro.GetRapidFeed();
operazione.Utensile.ParametroUtensile.SetFeed(program, rapidFeed, 0, FeedType.Sync);
CreateSpecificProgram(program, operazione);
return(program);
}
//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);
}
}
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.
}
}
internal override void SetFeed(ProgramOperation program, double rapidFeed, double secureRapidFeed, FeedType feedType)
{
var nGiri = GetSpeed();
var feed = GetFeed(FeedType.ASync);
program.AddFeedType(MoveType.Rapid, VelocitaType.ASync, nGiri, VelocitaType.ASync, rapidFeed);
program.AddFeedType(MoveType.SecureRapidFeed, VelocitaType.ASync, nGiri, VelocitaType.ASync, secureRapidFeed);
program.AddFeedType(new[] { MoveType.Work, MoveType.Cw, MoveType.Ccw, MoveType.PlungeFeed }, VelocitaType.ASync, nGiri, VelocitaType.ASync, feed);
}
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);
}
}
/// <summary>
/// forse questo metodo non è necessario che risieda qui..
/// </summary>
/// <param name="programPhase"></param>
/// <returns></returns>
public List <IPreviewEntity> GetPreview(ProgramOperation programPhase)
{
if (programPhase == null)
{
return(null);
}
var path3D = new PreviewPathBuilder();
// path3D.SetStartPoint(CurrentX, CurrentY, CurrentZ);
foreach (var programAction in programPhase.Azioni)
{
// qui fare metodo ricorsivo..
if (programAction is MacroForaturaAzione)
{
var macro = programAction as MacroForaturaAzione;
//CreatePreview(programAction as MacroDrillingAction, path3D);
foreach (var v in macro.MoveActionCollection)
{
if (v is ArcMoveAction)
{
var moveAction = programAction as ArcMoveAction;
AddElement(path3D, moveAction);
}
else
{
AddElement(path3D, v);
}
}
}
else if (programAction is ArcMoveAction)
{
var moveAction = programAction as ArcMoveAction;
AddElement(path3D, moveAction);
}
else if (programAction is LinearMoveAction)
{
var moveAction = programAction as LinearMoveAction;
AddElement(path3D, moveAction);
}
}
return(path3D.GetProfile());
}
internal override void SetFeed(ProgramOperation program, double rapidFeed, double secureRapidFeed, FeedType feedType)
{
var velocitaType = ModalitaVelocita == ModalitaVelocita.GiriFissi ? VelocitaType.ASync : VelocitaType.Sync;
var feedT = feedType == FeedType.Sync ? VelocitaType.Sync : VelocitaType.ASync;
var feed = AvanzamentoSincrono;
var speed = Velocita;
program.AddFeedType(MoveType.Rapid, VelocitaType.ASync, speed, VelocitaType.ASync, rapidFeed);
program.AddFeedType(MoveType.SecureRapidFeed, VelocitaType.ASync, speed, feedT, secureRapidFeed);
// queste sono le uniche tipologie di movimento possibili in operazione di tornio
// poi c'è sosta programmata ..
program.AddFeedType(new[] { MoveType.Work, MoveType.Cw, MoveType.Ccw }, velocitaType, speed, feedT, feed);
}
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);
}
}
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 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);
}
}
internal override ProgramOperation GetOperationProgram(Operazione operazione)
{
/*
* - init program
* - toolChange ( poi in fase di calcolo programma vedo se saltarlo o meno )
* - settaggio feed. ( vedere meglio)
*
* -- calcolo programma ( questo è l'unica parte diversa )
*
* - rototraslazione operazioni
*/
// todo : tenere conto anche dell'asse c attivazione g112 per il tornio ..
// Creo nuovo programma, tutte le lavorazioni ( hanno Z Sicurezza )
// anche perchè pensavo di settarla a livello di fase di lavoro..
var program = new ProgramOperation(SicurezzaZ);
// Se cambio utensile è opzionale , oppure se è forzato non cambio utensile..
//var cambioUtensile = (operazione.ToolChangeOptional && operazione.ForceToolChange) || !operazione.ToolChangeOptional;
var changeToolAction = new CambiaUtensileAction(program, operazione);
changeToolAction.CutViewerToolInfo = CutViewerHelper.PrintTool(operazione.Utensile);
// Ora setto avanzamenti comuni - Rapido - SecureFeed - Ecc..
// per ora setto cazzo .. dove lo posso prendere ??
var preference = Singleton.Preference.GetPreference(MeasureUnit);
ExtraCorsa = preference.MillEntryExitSecureDistance;
SecureFeed = preference.MillingRapidSecureFeedAsync;
/*
* L'idea per i feed e di cercare di inserirli tutti nel dizionario, se poi vengono usati ok,
* altrimenti è lo stesso..
*/
// Magari è piu corretto settarle nella classe base parametro..
var feed = operazione.Utensile.ParametroUtensile.GetFeed(FeedType.ASync);
var plungeFeed = operazione.Utensile.ParametroUtensile.GetPlungeFeed(FeedType.ASync);
/*
* Non controllo più che i feed siano <= 0 , al limite nel prog ci sarà scritto F0
*/
var rapidFeed = FaseDiLavoro.GetRapidFeed();
operazione.Utensile.ParametroUtensile.SetFeed(program, rapidFeed, SecureFeed, FeedType.ASync);
//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);
/*
* ora c'è richiamo il metodo specifico della lavorazione.
* In ingresso prende il ProgramPhase. e Operazione.
*/
CreateSpecificProgram(program, operazione);
/*
* todo.
* qui andrebbe il metodo per fare le rototraslazioni.
* per ora lo lascio delegato alla lavorazione specifica
* per via del problemi con ciclo di foratura..
*/
return(program);
}
internal abstract void SetFeed(ProgramOperation program, double rapidFeed, double secureRapidFeed, FeedType feedType);
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)
{
/*
* 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);
}
}
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 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> /// Metodo astratto dove si genera la parte del programma specifica di ogni lavorazione. /// La parte in comune è stata raggruppata nel metodo GetOperationProgram. /// </summary> /// <param name="programPhase"></param> /// <param name="operazione"></param> protected abstract void CreateSpecificProgram(ProgramOperation programPhase, Operazione operazione);
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);
}
}
/// <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);
}
}
/*
* come operation program anche qui posso fare come preview per gestire array e rotazioni.
*
* ovverro
*
* in quanto il codice per creare la parte e richiamo utensile puo esserre messo in modo astratto
*
* la parte che mi serve è solamente qella relativa al codice , comunque per ora non me ne proccoupa
*/
internal List <IPreviewEntity> GetPathPreview(ProgramOperation programPhase, ToolMachine.ToolMachine toolMachine)
{
return(toolMachine.GetPreview(programPhase));
}
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);
}
}
