예제 #1
0
        protected override void CreateCodeFromAction(MacroForaturaAzione macro, ref StringBuilder code)
        {
            //if (drillingAction.DrillPoints == null)
            //    throw new NullReferenceException();

            //var pnts = drillingAction.DrillPoints.ToList();

            //if (pnts.Count() == 0)
            //    return;

            //var firstPnt = pnts.First();

            //switch (drillingAction.DrillMacroTypeEnum)
            //{
            //    default:
            //    case ModalitaForatura.Semplice:
            //        {
            //            WriteSimpleDrilling(ref code, firstPnt, drillingAction.Dweel);
            //        } break;
            //}

            //// il primo è già stampato..
            //for (var i = 1; i < pnts.Count(); i++)
            //{
            //    var pnt = pnts[i];

            //    MoveToAngularCoordinate(pnt.X, pnt.Y, 0, ref code);
            //}

            //code.AppendLine("G80");
            ///*
            // * i punti nelle macro di foratura vanno espressini in angolo & diametro
            // */
        }
예제 #2
0
        internal List <IEntity2D> CreatePreview(MacroForaturaAzione foraturaAzione)
        {
            //var rslt = new List<IEntity2D>();

            //if (drillingAction.DrillPoints == null)
            //    throw new NullReferenceException();

            //var pntList = drillingAction.DrillPoints.ToList();

            //if (pntList.Count <= 0)
            //    return null;

            //var initPnt = new Point3D();

            //initPnt.X = 100;
            //initPnt.Y = 100;
            //initPnt.Z = 100;


            //var prevPnt = initPnt;

            //foreach (var point2D in pntList)
            //{
            //    var attacLine = new Line3D();

            //    attacLine.Start = new Point3D(prevPnt);

            //    var secureZ = drillingAction.SecureZ;

            //    attacLine.End = new Point3D(point2D.X, point2D.Y, secureZ);

            //    rslt.Add(attacLine);

            //    var drillLine = new Line3D();

            //    drillLine.Start = new Point3D(attacLine.End);

            //    drillLine.End = new Point3D(attacLine.End);

            //    var endZ = drillingAction.EndZ;

            //    drillLine.End.Z = endZ;

            //    rslt.Add(drillLine);

            //    var retractLine = new Line3D();

            //    retractLine.Start = new Point3D(drillLine.End);

            //    retractLine.End = new Point3D(drillLine.Start);

            //    rslt.Add(retractLine);
            //}

            //return rslt;
            return(null);
        }
예제 #3
0
        /// <summary>
        /// Crea codice da macro drilling action
        /// </summary>
        /// <param name="macro"></param>
        /// <param name="code"></param>
        protected virtual void CreateCodeFromAction(MacroForaturaAzione macro, ref StringBuilder code)
        {
            /*
             * si muove in xy del primo elemento
             * zSicurezza
             * calcola R
             * macro
             * listaPunti
             * chiudeMacro.
             */

            string macroCode;

            var firstPoint = macro.PuntiForatura.FirstOrDefault();

            if (firstPoint == null)
            {
                return;
            }

            var firstMoveCode = string.Empty;

            WriteMoveToX(firstPoint.X, ref firstMoveCode, true);
            WriteMoveToY(firstPoint.Y, ref firstMoveCode, true);

            code.AppendLine(firstMoveCode);

            var toZ = string.Empty;

            WriteMoveToZ(macro.SicurezzaZ, ref toZ, true);

            code.AppendLine(toZ);

            switch (macro.TipologiaLavorazione)
            {
            case LavorazioniEnumOperazioni.ForaturaAlesatore:
            {
                macroCode = "G85";
            } break;

            case LavorazioniEnumOperazioni.ForaturaMaschiaturaDx:
            {
                macroCode = "G84";
            } break;

            case LavorazioniEnumOperazioni.ForaturaMaschiaturaSx:
            {
                macroCode = "G84.1";
            } break;

            case LavorazioniEnumOperazioni.ForaturaBareno:
            {
                macroCode = "G84";
            } break;

            case LavorazioniEnumOperazioni.ForaturaPunta:
            {
                switch (macro.ModalitaForatura)
                {
                case ModalitaForatura.StepScaricoTruciolo:
                {
                    macroCode = "G83";
                } break;

                case ModalitaForatura.StepSenzaScaricoTruciolo:
                {
                    macroCode = "G83";
                } break;

                default:
                case ModalitaForatura.Semplice:
                {
                    macroCode = "G81";
                } break;
                }
            } break;


            default:
            case LavorazioniEnumOperazioni.ForaturaCentrino:
            case LavorazioniEnumOperazioni.ForaturaSmusso:
            case LavorazioniEnumOperazioni.ForaturaLamatore:
            {
                macroCode = "G81";
            } break;
            }

            macroCode += ("Z" + FormatCoordinate(macro.EndZ));

            if (macro.Step > 0)
            {
                macroCode += ("Q" + FormatCoordinate(macro.Step));
            }

            //if (macro.IncrementoR > 0)
            macroCode += ("R" + FormatCoordinate(macro.CodiceR));

            if (macro.Sosta > 0)
            {
                macroCode += ("P" + FormatCoordinate(macro.Sosta));
            }

            /*
             * Qui inserisco valore avanzamento.
             * todo - gestire anche modalità avanzamento - sincrono asincrono
             */
            if (macro.ParametriTaglio != null)
            {
                if (macro.ParametriTaglio.ValoreFeed > 0)
                {
                    macroCode += "F" + (FormatFeed(macro.ParametriTaglio.ValoreFeed));
                }
            }

            code.AppendLine(macroCode);

            for (var i = 1; i < macro.PuntiForatura.Count(); i++)
            {
                var pnt = macro.PuntiForatura.ElementAt(i);

                code.Append("X" + FormatCoordinate(pnt.X));
                code.Append("Y" + FormatCoordinate(pnt.Y));
                code.Append("\n");
            }

            code.AppendLine("G80");
            code.AppendLine(toZ);
        }
예제 #4
0
        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");
            }
        }
예제 #5
0
        /// <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);
            }
        }