Ejemplo n.º 1
0
        public void WriteCommand(Azioni azione, Pinza pinza, Stazioni stazione, PosizioneSchedaForRobot pos)
        {
            CommandPending = true;
            byte[] msg = Encoding.ASCII.GetBytes($"[{(int)azione},{(int)pinza},{(int)stazione},{(int)pos}]");
            _handlerMain.Send(msg);

            _data = null;

            // An incoming connection needs to be processed.
            while (true)
            {
                _bytes = new byte[1024];
                int bytesRec = _handlerMain.Receive(_bytes);
                _data  = null;
                _data += Encoding.ASCII.GetString(_bytes, 0, bytesRec);
                if (_data.IndexOf("cmd_ok#") > -1)
                {
                    Console.WriteLine("Comando Ricevuto da Robot");
                }
                else if (_data.IndexOf("cmd_end#") > -1)
                {
                    Console.WriteLine("Comando Completato dal Robot");
                    CommandPending = false;
                    break;
                }
            }
        }
Ejemplo n.º 2
0
 public Compact(Stazioni stazione)
 {
     StazioneCompact = stazione;
     Posizione_1     = new Slot();
     Posizione_2     = new Slot();
     Posizione_3     = new Slot();
     Posizione_4     = new Slot();
 }
Ejemplo n.º 3
0
 private void executeCommand(Azioni azione, Pinza pinza, Stazioni stazione, PosizioneSchedaForRobot posizione)
 {
     if (_robot != null && _robot.AreCommandsEnabled && !_robot.CommandPending)
     {
         _robot.WriteCommand(azione, pinza, stazione, posizione);
     }
     else if (_robot != null)
     {
         MessageBox.Show("Definire istanza Robot");
     }
     else if (_robot.CommandPending)
     {
         MessageBox.Show("Attendere la fine del comando in esecuzione dal robot");
     }
 }
Ejemplo n.º 4
0
        private void CommandExecuter(Azione a, Stazioni s, Compact compact = null)
        {
            foreach (var c in a.Comandi)
            {
                #region Good
                if (c.Azione == AzioneTabella.Good && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.None)
                {
                    Scheda scheda = _schede.FirstOrDefault(i =>
                                                           i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                                                           i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_1);
                    if (scheda == null)
                    {
                        Console.WriteLine("Nessuna scheda da deposiatre nella postazione di scarico, su pinza 1");
                        return;
                    }

                    _robot.WriteCommand(Azioni.Deposito, Pinza.Pinza_1, Stazioni.Scarico, PosizioneSchedaForRobot.Posizione_1);
                    _schede.Remove(scheda);
                    continue;
                }

                if (c.Azione == AzioneTabella.Good && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.None)
                {
                    Scheda scheda = _schede.FirstOrDefault(i =>
                                                           i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                                                           i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_2);
                    if (scheda == null)
                    {
                        Console.WriteLine("Nessuna scheda da deposiatre nella postazione di scarico, su pinza 1");
                        return;
                    }

                    _robot.WriteCommand(Azioni.Deposito, Pinza.Pinza_2, Stazioni.Scarico, PosizioneSchedaForRobot.Posizione_1);
                    _schede.Remove(scheda);

                    continue;
                }
                #endregion

                #region Pick Pinza 1

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.G)
                {
                    //Pick di un pezzo buono da compact
#warning check if compact is opened
                    //throw new NotImplementedException("Check if compact is opened");
                    int slot = compact.GiveMeTheFirstGoodToPick();
                    if (slot == -1)
                    {
                        Console.WriteLine("La compact non ha nessun pezzo risultato buono");
                        return;
                    }
                    _robot.WriteCommand(Azioni.Prelievo, Pinza.Pinza_1, compact.StazioneCompact, (PosizioneSchedaForRobot)slot);
                    compact.ReleaseSlot(slot);
                    _schede.FirstOrDefault(i =>
                                           i.PosizioniUtilizzate.Last().Stazione == compact.StazioneCompact &&
                                           i.PosizioniUtilizzate.Last().Posizione == (PosizioneSchedaForRobot)slot)
                    .PosizioniUtilizzate.Add(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Pinza,
                        Posizione = PosizioneSchedaForRobot.Posizione_1
                    });
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.In)
                {
                    if (compact.GiveMeTheFirstEmptySlot() == -1)
                    {
                        Console.WriteLine("Attenzione, nessuno slot della compact è vuoto");
                        return;
                    }

                    //Lettura da plc per sapere dove devo andare a prendere la scheda
                    int pos = 1;//<-Lettura da PLC
                    _robot.WriteCommand(Azioni.Prelievo, Pinza.Pinza_1, Stazioni.Carico, (PosizioneSchedaForRobot)pos);
                    Scheda nuova = new Scheda(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Carico,
                        Posizione = (PosizioneSchedaForRobot)pos
                    });

                    nuova.AddPosition(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Pinza,
                        Posizione = PosizioneSchedaForRobot.Posizione_1
                    });
                    _schede.Add(nuova);
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.R)
                {
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.W)
                {
                    continue;
                }

                #endregion

                #region Pick Pinza 2

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.G)
                {
                    //Pick di un pezzo buono da compact
#warning check if compact is opened
                    //throw new NotImplementedException("Check if compact is opened");
                    int slot = compact.GiveMeTheFirstGoodToPick();
                    if (slot == -1)
                    {
                        Console.WriteLine("La compact non ha nessun pezzo risultato buono");
                        return;
                    }
                    _robot.WriteCommand(Azioni.Prelievo, Pinza.Pinza_2, compact.StazioneCompact, (PosizioneSchedaForRobot)slot);
                    compact.ReleaseSlot(slot);
                    _schede.FirstOrDefault(i =>
                                           i.PosizioniUtilizzate.Last().Stazione == compact.StazioneCompact &&
                                           i.PosizioniUtilizzate.Last().Posizione == (PosizioneSchedaForRobot)slot)
                    .PosizioniUtilizzate.Add(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Pinza,
                        Posizione = PosizioneSchedaForRobot.Posizione_2
                    });
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.In)
                {
                    if (compact.GiveMeTheFirstEmptySlot() == -1)
                    {
                        Console.WriteLine("Attenzione, nessuno slot della compact è vuoto");
                        return;
                    }

                    //Lettura da plc per sapere dove devo andare a prendere la scheda
                    int pos = 2;//<-Lettura da PLC
                    _robot.WriteCommand(Azioni.Prelievo, Pinza.Pinza_2, Stazioni.Carico, (PosizioneSchedaForRobot)pos);
                    Scheda nuova = new Scheda(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Carico,
                        Posizione = (PosizioneSchedaForRobot)pos
                    });

                    nuova.AddPosition(new PosizioneScheda
                    {
                        Stazione  = Stazioni.Pinza,
                        Posizione = PosizioneSchedaForRobot.Posizione_2
                    });
                    _schede.Add(nuova);
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.R)
                {
                    continue;
                }

                if (c.Azione == AzioneTabella.Pick && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.W)
                {
                    continue;
                }

                #endregion

                #region Place

                if (c.Azione == AzioneTabella.Place && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.None)
                {
                    //check se ci sono schede sulla pinza 1
                    if (_schede.FirstOrDefault(i =>
                                               i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                                               i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_1)
                        == null)
                    {
                        Console.WriteLine("Attenzione, Non sono presenti schede da posizionare sulla pinza 1");
                        return;
                    }


                    int slot = compact.GiveMeTheFirstEmptySlot();
                    _robot.WriteCommand(Azioni.Deposito, Pinza.Pinza_1, s, (PosizioneSchedaForRobot)slot);

                    //informare la posizione della compact che è occupata
                    compact.AddToEmptySlot(slot);
                    //informare la scheda della sua nuova posizione

                    Scheda scheda = _schede.FirstOrDefault(
                        i => i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                        i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_1);

                    scheda.PosizioniUtilizzate.Add(new PosizioneScheda()
                    {
                        Stazione  = compact.StazioneCompact,
                        Posizione = (PosizioneSchedaForRobot)slot
                    });
                    continue;
                }

                if (c.Azione == AzioneTabella.Place && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.None)
                {
                    //check se ci sono schede sulla pinza 2
                    if (_schede.FirstOrDefault(i =>
                                               i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                                               i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_2)
                        == null)
                    {
                        Console.WriteLine("Attenzione, Non sono presenti schede da posizionare sulla pinza 2");
                        return;
                    }

                    int slot = compact.GiveMeTheFirstEmptySlot();
                    _robot.WriteCommand(Azioni.Deposito, Pinza.Pinza_2, s, (PosizioneSchedaForRobot)slot);

                    //informare la posizione della compact che è occupata
                    compact.AddToEmptySlot(slot);
                    //informare la scheda della sua nuova posizione

                    Scheda scheda = _schede.FirstOrDefault(
                        i => i.PosizioniUtilizzate.Last().Stazione == Stazioni.Pinza &&
                        i.PosizioniUtilizzate.Last().Posizione == PosizioneSchedaForRobot.Posizione_2);

                    scheda.PosizioniUtilizzate.Add(new PosizioneScheda()
                    {
                        Stazione  = compact.StazioneCompact,
                        Posizione = (PosizioneSchedaForRobot)slot
                    });
                    continue;
                }

                #endregion

                #region Waste
                if (c.Azione == AzioneTabella.Waste && c.Pinza == Pinza.Pinza_1 && c.Parametro == ParametriTabella.None)
                {
                    continue;
                }

                if (c.Azione == AzioneTabella.Waste && c.Pinza == Pinza.Pinza_2 && c.Parametro == ParametriTabella.None)
                {
                    continue;
                }
                #endregion
            }
        }