public static CScaleWeight GetStabile()
        {
            CWeight      w = null;
            CScaleWeight s = new CScaleWeight();

            try
            {
                long lClock = Environment.TickCount;

                do
                {
                    cGlobalScale.objCIND890APIClient.CurrentScale.GetGNTInPrimaryUnit(ref s);

                    if (s.WeightStable == true && s.Status == CScaleWeight.enumScaleStatus.STATUS_WEIGHTOK)
                    {
                        //w = s.NetWeight;
                        //Trace.WriteLine(w.Weight.ToString() + " " + w.Unit + " ==>" + w.Status.ToString() + " =>STABIL");
                        break;
                    }
                    else if (s.WeightStable == false && s.Status == CScaleWeight.enumScaleStatus.STATUS_WEIGHTOK)
                    {
                        //w = s.NetWeight;
                        //Trace.WriteLine(w.Weight.ToString() + " " + w.Unit + " ==>" + w.Status.ToString() + " =>DYNAMISCH");
                    }
                    else
                    {
                        //Trace.WriteLine("ERROR");
                    }

                    if (Environment.TickCount - lClock > 4000)
                    {
                        break;
                    }
                }while (true);
            }
            catch (Exception ex)
            {
                SiAuto.LogException(ex);
                throw;
            }

            if (s.WeightStable == true && s.Status == CScaleWeight.enumScaleStatus.STATUS_WEIGHTOK)
            {
                return(s);
            }
            else
            {
                return(null);
            }
        }
Ejemplo n.º 2
0
        private bool Lese_Gewicht(ref CScaleWeight sLinks, ref CScaleWeight sRechts)
        {
            bool bRet = false;

            sRechts = null;
            sLinks  = null;

            try
            {
                sLinks = cGlobalScale.GetStabile(/*Linke oder Rechte Waage*/ 0);

                if (sLinks == null)
                {
                    // Hide Message Panel
                    this.ZeigeMeldung("");

                    this.dispWaitText.Visible = false;
                    this.ZeigeFehlerMeldung("Fehler\nKein gültiges Gewicht");
                    bRet = false;
                }
                else
                {
                    sRechts = cGlobalScale.GetStabile(/*Linke oder Rechte Waage*/ 1);

                    if (sRechts == null)
                    {
                        // Hide Message Panel
                        this.ZeigeMeldung("");

                        this.dispWaitText.Visible = false;
                        this.ZeigeFehlerMeldung("Fehler\nKein gültiges Gewicht");
                        bRet = false;
                    }
                    else
                    {
                        bRet = true;
                    }
                }
            }
            catch (Exception ex)
            {
                SiAuto.LogException("Wiegen", ex);
            }


            return(bRet);
        }
        /// <summary>
        /// Wenn SimuWert >=0 dann wird Simuwert verwendet
        /// </summary>
        /// <param name="dSimuWert"></param>
        /// <returns></returns>
        private void Starte_Gewichtsübernahme(double dSimuWert)
        {
            try
            {
                this.ZeigeMeldung("Bitte warten, Lese Gewicht");

                CScaleWeight scaleWeight = null;

                // Lese Gewicht von Waage mit Fehlerhandling
                if (!this.Lese_Gewicht(ref scaleWeight, dSimuWert))
                {
                    this.cmdCancel.Visible = true;
                    this.cmdRetry.Visible  = true;
                }
                else
                {
                    // Positives Gewicht. Summe zu der Palette hinzufügen
                    objSelAktivUserControl.objBeladungsDaten.dWiegung_Gesamtgewicht += scaleWeight.NetWeight.Weight;
                    objSelAktivUserControl.objBeladungsDaten.iWiegung_Gesamtanzahl++;

                    // Die letzte Wiegung für das Storno puffern um gegebenenfalls minus rechnen zu können
                    objSelAktivUserControl.objBeladungsDaten.dWiegung_LastNetto = scaleWeight.NetWeight.Weight;

                    //iCurr.dtWiegezeitpunkt = DateTime.Now;
                    //iCurr.dBrutto = scaleWeight.GrossWeight.Weight;
                    //iCurr.dTara = scaleWeight.TareWeight.Weight;
                    //iCurr.dNetto = scaleWeight.NetWeight.Weight;

                    DialogResult = DialogResult.OK;
                    cWiegung_Handling.Save_Palette(objSelAktivUserControl);
                    this.Close();
                }
            }
            catch (Exception ex)
            {
                SiAuto.LogException(ex);
            }
            finally
            {
                // Hide Message Panel
                this.ZeigeMeldung("");

                this.dispWaitText.Visible = false;
                Application.DoEvents();
            }
        }
        public static CScaleWeight GetDynamic()
        {
            CScaleWeight s = new CScaleWeight();

            try
            {
                long lClock = Environment.TickCount;

                do
                {
                    cGlobalScale.objCIND890APIClient.CurrentScale.GetGNTInPrimaryUnit(ref s);

                    if (s.Status == CScaleWeight.enumScaleStatus.STATUS_WEIGHTOK)
                    {
                        break;
                    }

                    if (Environment.TickCount - lClock > 4000)
                    {
                        break;
                    }
                }while (true);
            }
            catch (Exception ex)
            {
                SiAuto.LogException(ex);
                throw;
            }

            if (s.Status == CScaleWeight.enumScaleStatus.STATUS_WEIGHTOK)
            {
                return(s);
            }
            else
            {
                return(null);
            }
        }
Ejemplo n.º 5
0
        private void Starte_DIO_Test()
        {
            #region Phase 1
            try
            {
                CScaleWeight sw = cGlobalScale.GetDynamic();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "DIO Test Phase 1");
            }
            #endregion

            #region Phase 2
            try
            {
                CWeight w = cGlobalScale.objCIND890APIClient.CurrentScale.DisplayWeight;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "DIO Test Phase 2");
            }
            #endregion

            #region Phase 3
            try
            {
                CDiscreteIO oDiscreteIO = cGlobalScale.objCIND890APIClient_DigitalIO.DiscreteIO;

                if (oDiscreteIO == null)
                {
                    MessageBox.Show("DIO NULL", "DIO Test Phase 3>>");
                }

                //for (int iLocation = 0; iLocation < 10; iLocation++)
                //{

                //    #region Phase 4
                //    try
                //    {
                //        if (oDiscreteIO != null)
                //        {
                //            oDiscreteIO.WriteToDIO((byte)iLocation, 5, 0);
                //        }
                //    }
                //    catch (Exception ex)
                //    {
                //        MessageBox.Show(ex.Message, iLocation.ToString() + ">>> DIO Test Phase 4");
                //    }
                //    #endregion
                //}
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "DIO Test Phase 3");
            }
            #endregion

            try
            {
                var fdio = new frmDIOTest();
                fdio.ShowDialog();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "DIO Test Start");
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Wenn SimuWert >=0 dann wird Simuwert verwendet
        /// </summary>
        /// <param name="dSimuWert"></param>
        /// <returns></returns>
        private bool Starte_Gewichtsübernahme(double dSimuWertLinks, double dSimuWertRechts)
        {
            bool bRet = true;

            try
            {
                if (this.iAktiveAchse == 1)
                {
                    this.ZeigeMeldung("Bitte warten, Lese Gewicht Erstwiegung");
                }
                else if (this.iAktiveAchse == 2 &&
                         ((objWiegung.objWiegeItem_W1.dNetto_Links + objWiegung.objWiegeItem_W1.dNetto_Rechts) > 0))
                {
                    this.ZeigeMeldung("Bitte warten, Lese Gewicht Zweitwiegung");
                }
                else
                {
                    this.ZeigeMeldung("");

                    this.dispWaitText.Visible = false;
                    this.ZeigeFehlerMeldung("Fehler\nKein gültiges Gewicht");
                    bRet = false;
                }

                CScaleWeight wLinks  = null;
                CScaleWeight wRechts = null;

                // Lese Gewicht von Waage Links und Rechts mit Fehlerhandling und Anzeige
                if (!this.Lese_Gewicht(ref wLinks, ref wRechts))
                {
                    bRet = false;
                }
                else
                {
                    // Hier muss die Simulation rein
                    if ((dSimuWertLinks >= 0) && (iAktiveAchse == 1))
                    {
                        wLinks.NetWeight  = new CWeight(dSimuWertLinks, 0, "kg");
                        wRechts.NetWeight = new CWeight(dSimuWertRechts, 0, "kg");
                    }
                    else if ((dSimuWertLinks >= 0) && (iAktiveAchse == 2))
                    {
                        wLinks.NetWeight  = new CWeight(dSimuWertLinks, 0, "kg");
                        wRechts.NetWeight = new CWeight(dSimuWertRechts, 0, "kg");
                    }
                    // Ende Simulation

                    #region Prüfe Plausibilität der Gewichtsübernahme
                    if ((wLinks.NetWeight.Weight + wRechts.NetWeight.Weight) > 5000)
                    {
                        this.dispWaitText.Visible = false;
                        if (this.iAktiveAchse == 1)
                        {
                            this.Achse1Farbe(2);
                        }
                        else
                        {
                            this.Achse2Farbe(2);
                        }
                        this.ZeigeFehlerMeldung("Fehler\nÜber Maximalgewicht");
                        bRet = false;
                    }

                    if (this.iAktiveAchse == 2)
                    {
                        if (((this.objWiegung.objWiegeItem_W1.dNetto_Links + this.objWiegung.objWiegeItem_W1.dNetto_Rechts) +
                             (wLinks.NetWeight.Weight + wRechts.NetWeight.Weight)) > 9000)
                        {
                            this.dispWaitText.Visible = false;
                            this.Achse1Farbe(2);
                            this.Achse2Farbe(2);
                            this.ZeigeFehlerMeldung("Gesamtgewicht zu hoch (max. 9000)");
                            bRet = false;
                        }
                    }
                    #endregion

                    // Wenn Wiegung positiv und Plausibilitäten geprüft
                    //if ( bRet)
                    //{
                    Data.cData_Wiegung_Item iCurr = null;

                    if (this.iAktiveAchse == 1)
                    {
                        iCurr = this.objWiegung.objWiegeItem_W1;
                    }
                    else
                    {
                        iCurr = this.objWiegung.objWiegeItem_W2;
                    }


                    iCurr.dBrutto_Links = wLinks.GrossWeight.Weight;
                    iCurr.dNetto_Links  = wLinks.NetWeight.Weight;
                    iCurr.dTara_Links   = wLinks.TareWeight.Weight;

                    iCurr.dBrutto_Rechts = wRechts.GrossWeight.Weight;
                    iCurr.dNetto_Rechts  = wRechts.NetWeight.Weight;
                    iCurr.dTara_Rechts   = wRechts.TareWeight.Weight;

                    iCurr.dtWiegung = DateTime.Now;
                    iCurr.sEinheit  = wLinks.NetWeight.Unit;

                    if (this.iAktiveAchse == 1)
                    {
                        Allgemein.cGlobalHandling.TransferRS232(ref objWiegung, 1, this.bWiegung1Erfolgt, this.bWiegung2Erfolgt);
                    }
                    //}
                }

                if (bRet && this.iAktiveAchse == 1)
                {
                    this.Achse1Farbe(1);
                    this.iAktiveAchse = 2;
                }

                this.UpdateGui();
            }
            catch (Exception ex)
            {
                SiAuto.LogException(ex);
            }
            finally
            {
                // Hide Message Panel
                this.ZeigeMeldung("");

                this.dispWaitText.Visible = false;
                Application.DoEvents();
            }

            return(bRet);
        }
        private bool Lese_Gewicht(ref CScaleWeight scaleWeight, double dSimuWert)
        {
            bool bRet = false;

            scaleWeight = null;

            try
            {
                scaleWeight = cGlobalScale.GetDynamic();

                if (scaleWeight == null)
                {
                    // Hide Message Panel
                    this.ZeigeMeldung("");

                    this.dispWaitText.Visible = false;
                    this.ZeigeFehlerMeldung("Fehler\nKein gültiges Gewicht!");
                    bRet = false;
                }
                else
                {
                    // Hier muss die Simulation rein
                    if (dSimuWert >= 0)
                    {
                        scaleWeight.NetWeight = new CWeight(dSimuWert, 0, "kg");
                    }
                    // Ende Simulation
                }


                if (scaleWeight.NetWeight.Weight > this.objWiegung.objSettings.dEinzelWiegungMaxGewicht)
                {
                    // Hide Message Panel
                    this.ZeigeMeldung("");

                    this.dispWaitText.Visible = false;
                    this.ZeigeFehlerMeldung("Gewicht über Maximalgewicht!");
                    bRet = false;
                }
                else if (scaleWeight.NetWeight.Weight < this.objWiegung.objSettings.dEinzelWiegungMinGewicht)
                {
                    // Hide Message Panel
                    this.ZeigeMeldung("");

                    this.dispWaitText.Visible = false;
                    this.ZeigeFehlerMeldung("Gewicht unter Minimalgewicht!");
                    bRet = false;
                }
                else
                {
                    bRet = true;
                }
            }
            catch (Exception ex)
            {
                SiAuto.LogException("Wiegen", ex);
            }


            return(bRet);
        }