Exemplo n.º 1
0
        public MainForm(string sFile)
        {
#if CALLSTACK
            Console.WriteLine("CALLSTACK:MainForm");
#endif

            try
            {
                if (!String.IsNullOrEmpty(sFile))
                    m_sStartFile = sFile;

                SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
                SetStyle(ControlStyles.AllPaintingInWmPaint, true);
                SetStyle(ControlStyles.UserPaint, true);
                InitializeComponent();

                InitializeRFGenTab();

                m_GraphSpectrumAnalyzer = new ZedGraph.ZedGraphControl();
                m_WaterfallSweepMaxHold = new RFESweepDataCollection(100, false);
                m_Markers = new MarkerCollection();
                m_Markers.Initialize();
                CreateMarkerMenu();

                m_objRFEAnalyzer = new RFECommunicator();
                m_objRFEAnalyzer.PortClosedEvent += new EventHandler(OnAnalyzerPortClosed);
                m_objRFEAnalyzer.PortConnectedEvent += new EventHandler(OnAnalyzerPortConnected);
                m_objRFEAnalyzer.ReportInfoAddedEvent += new EventHandler(OnAnalyzerReportLog);
                m_objRFEAnalyzer.ReceivedConfigurationDataEvent += new EventHandler(OnAnalyzerReceivedConfigData);
                m_objRFEAnalyzer.UpdateDataEvent += new EventHandler(OnAnalyzerUpdateData);
                m_objRFEAnalyzer.UpdateRemoteScreenEvent += new EventHandler(OnAnalyzerUpdateRemoteScreen);
                m_objRFEAnalyzer.ReceivedDeviceModelEvent += new EventHandler(OnAnalyzerReceivedDeviceModel);
                m_objRFEAnalyzer.UpdateDataTrakingNormalizationEvent += new EventHandler(OnAnalyzerUpdateDataTrakingNormalization);
                m_objRFEAnalyzer.UpdateDataTrakingEvent += new EventHandler(OnAnalyzerUpdateTrackingData);
                m_objRFEAnalyzer.ShowDetailedCOMPortInfo = false;

                m_groupCOMPortAnalyzer = new ToolGroupCOMPort();
                m_groupCOMPortAnalyzer.RFExplorer = m_objRFEAnalyzer;
                m_groupCOMPortAnalyzer.PortClosed += new EventHandler(OnAnalyzerButtons_PortClosed);
                m_groupCOMPortAnalyzer.PortConnected += new EventHandler(OnAnalyzerButtons_PortConnected);
                m_groupCOMPortAnalyzer.GroupBoxTitle = "COM Port Spectrum Analyzer";

                m_objRFEGenerator = new RFECommunicator();
                m_objRFEGenerator.PortClosedEvent += new EventHandler(OnGeneratorPortClosed);
                m_objRFEGenerator.PortConnectedEvent += new EventHandler(OnGeneratorPortConnected);
                m_objRFEGenerator.ReportInfoAddedEvent += new EventHandler(OnGeneratorReportLog);
                m_objRFEGenerator.ReceivedConfigurationDataEvent += new EventHandler(OnGeneratorReceivedConfigData);
                //m_objRFEGen.UpdateData += new EventHandler(OnRFE_UpdateData);
                m_objRFEGenerator.UpdateRemoteScreenEvent += new EventHandler(OnAnalyzerUpdateRemoteScreen);
                m_objRFEGenerator.ReceivedDeviceModelEvent += new EventHandler(OnGeneratorReceivedDeviceModel);
                m_objRFEGenerator.ShowDetailedCOMPortInfo = false;

                m_groupCOMPortGenerator = new ToolGroupCOMPort();
                m_groupCOMPortGenerator.RFExplorer = m_objRFEGenerator;
                //m_groupCOMPortGenerator.PortClosed += new EventHandler(OnGeneratorButtons_PortClosed);
                //m_groupCOMPortGenerator.PortConnected += new EventHandler(OnGeneratorButtons_PortConnected);
                m_groupCOMPortGenerator.GroupBoxTitle = "COM Port Signal Generator";

                printMainDocument.PrintPage += new System.Drawing.Printing.PrintPageEventHandler(this.printDocument_PrintPage);
                printMainDocument.DocumentName = "RF Explorer";
            }
            catch (Exception obEx)
            {
                string sReportFile = Environment.GetEnvironmentVariable("APPDATA") + "\\rfexplorer_crash.log";
                using (StreamWriter sr = new StreamWriter(sReportFile, true))
                {
                    sr.WriteLine(Environment.NewLine + Environment.NewLine +
                        "------------------------------------------------------------" + Environment.NewLine +
                        "Report log date " + DateTime.Now.ToString() + Environment.NewLine);
                    sr.WriteLine("Exception: " + obEx.ToString());
                    sr.Flush();
                }
            }
        }
Exemplo n.º 2
0
        public RFECommunicator()
        {
            InitializeModels();

            m_LastCaptureTime = new DateTime(2000, 1, 1);

            m_SweepDataContainer = new RFESweepDataCollection(100 * 1024, true);
            m_TrackingDataContainer = new RFESweepDataCollection(1024, true);
            m_ScreenDataContainer = new RFEScreenDataCollection();

            m_nScreenIndex = 0;

            m_arrReceivedData = new Queue();

            m_bRunReceiveThread = true;
            ThreadStart threadDelegate = new ThreadStart(this.ReceiveThreadfunc);
            m_ReceiveThread = new Thread(threadDelegate);
            m_ReceiveThread.Start();

            ReportLog("RFECommunicator library started.");

            for (int nInd = 0; nInd < m_arrFLASH.Length; nInd++)
            {
                m_arrFLASH[nInd] = new RFEMemoryBlock();
                m_arrFLASH[nInd].Address = (UInt32)(nInd * RFEMemoryBlock.MAX_BLOCK_SIZE);
            }

            try
            {
                m_serialPortObj = new SerialPort();
            }
            catch (Exception obEx)
            {
                ReportLog("Error in RFECommunicator constructor: " + obEx.ToString());
            }
        }
Exemplo n.º 3
0
 /// <summary>
 /// removes any prior loaeded normalization data
 /// </summary>
 public void ResetTrackingNormalizedData()
 {
     m_SweepTrackingNormalized = null;
     m_SweepTrackingNormalizedContainer = null;
 }
Exemplo n.º 4
0
        /// <summary>
        /// load a normalization SNA file and reconfigures m_SweepTrackingNormalized based on that
        /// </summary>
        /// <param name="sFilename"></param>
        /// <returns></returns>
        private bool LoadFileSNANormalization(string sFilename)
        {
            RFESweepDataCollection objCollection = new RFESweepDataCollection(1, true);
            string sModel, sConfig;
            if (objCollection.LoadFile(sFilename, out sModel, out sConfig))
            {
                if (!sModel.Contains(_RFEGEN_FILE_MODEL_Mark))
                    return false;

                int nIndRFEGen = sModel.IndexOf(_RFEGEN_FILE_MODEL_Mark);
                string sModelRFEGen = sModel.Substring(nIndRFEGen + 1 + _RFEGEN_FILE_MODEL_Mark.Length);
                nIndRFEGen = sConfig.IndexOf(_RFEGEN_FILE_MODEL_Mark);
                string sConfigRFEGen = sConfig.Substring(nIndRFEGen + 1 + _RFEGEN_FILE_MODEL_Mark.Length);
                m_SweepTrackingNormalized = objCollection.GetData(0);

                return UpdateOfflineConfigurationParameters_Generator(sConfigRFEGen, sModelRFEGen);
            }
            else 
                return false;
        }
Exemplo n.º 5
0
        public bool SaveFileSNANormalization(string sFilename)
        {
            if (!IsTrackingNormalized())
                return false;

            RFESweepDataCollection objCollection = new RFESweepDataCollection(1, true);
            objCollection.Add(TrackingNormalizedData);
            objCollection.SaveFile(sFilename, FullModelText + " - " + _RFEGEN_FILE_MODEL_Mark + " " + m_objRFEGen.FullModelText,
                ConfigurationText + " - " + _RFEGEN_FILE_MODEL_Mark + " " + m_objRFEGen.ConfigurationText, null);

            return true;
        }
Exemplo n.º 6
0
        public bool ProcessReceivedString(bool bProcessAllEvents, out string sReceivedString)
        {
            bool bDraw = false;
            sReceivedString = "";

            try
            {
                do
                {
                    bool bWrongFormat = false;
                    object objNew = null;
                    long nCount = 0;

                    try
                    {
                        Monitor.Enter(m_arrReceivedData);
                        nCount = m_arrReceivedData.Count;

                        if (nCount == 0)
                            break;
                        objNew = m_arrReceivedData.Dequeue();
                    }
                    catch (Exception obEx)
                    {
                        ReportLog("m_arrReceivedStrings processing: " + obEx.ToString());
                    }
                    finally
                    {
                        Monitor.Exit(m_arrReceivedData);
                    }

                    if (objNew.GetType() == typeof(RFEConfiguration))
                    {
                        RFEConfiguration objConfiguration = (RFEConfiguration)objNew;
                        ReportLog("Received configuration: " + objConfiguration.sLineString);

                        if (m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB == null)
                        {
                            //request internal calibration data, if available
                            SendCommand("Cq");
                        }

                        if (IsGenerator())
                        {
                            //signal generator
                            RFGenStartFrequencyMHZ = objConfiguration.fStartMHZ;
                            RFGenStepFrequencyMHZ = objConfiguration.fStepMHZ;
                            RFGenCWFrequencyMHZ = objConfiguration.fRFEGenCWFreqMHZ;
                            RFGenSweepSteps = objConfiguration.nFreqSpectrumSteps;
                            RFGenStopFrequencyMHZ = RFGenStartFrequencyMHZ + RFGenSweepSteps * RFGenStepFrequencyMHZ;
                            RFGenPowerON = objConfiguration.bRFEGenPowerON;
                            RFGenPowerLevel = objConfiguration.nRFEGenPowerLevel;
                            RFGenHighPowerSwitch = objConfiguration.bRFEGenHighPowerSwitch;

                            MaxFreqMHZ = 6000;
                            MinFreqMHZ = 23.438;

                            RFGenStepWaitMS = objConfiguration.nRFEGenSweepWaitMS;

                            OnReceivedConfigurationData(new EventArgs());
                        }
                        else
                        {
                            //spectrum analyzer
                            if ((Math.Abs(StartFrequencyMHZ - objConfiguration.fStartMHZ) >= 0.001) || (Math.Abs(StepFrequencyMHZ - objConfiguration.fStepMHZ) >= 0.001))
                            {
                                StartFrequencyMHZ = objConfiguration.fStartMHZ;
                                StepFrequencyMHZ = objConfiguration.fStepMHZ;
                                ReportLog("New Freq range - buffer cleared.");
                            }
                            AmplitudeTopDBM = objConfiguration.fAmplitudeTopDBM;
                            AmplitudeBottomDBM = objConfiguration.fAmplitudeBottomDBM;
                            FreqSpectrumSteps = objConfiguration.nFreqSpectrumSteps;
                            m_bExpansionBoardActive = objConfiguration.bExpansionBoardActive;
                            if (m_bExpansionBoardActive)
                            {
                                m_eActiveModel = m_eExpansionBoardModel;
                                if (ExpansionBoardModel == RFECommunicator.eModel.MODEL_WSUB3G)
                                {
                                    //If it is a MODEL_WSUB3G, make sure we use the MAX HOLD mode to account for proper DSP
                                    Thread.Sleep(500);
                                    if (m_bUseMaxHold)
                                    {
                                        ReportLog("Updated remote mode to Max Hold for reliable DSP calculations with fast signals");
                                        SendCommand_SetMaxHold();
                                    }
                                    else
                                    {
                                        ReportLog("Remote mode is not Max Hold, some fast signals may not be detected");
                                        SendCommand_Realtime();
                                    }
                                }
                            }
                            else
                            {
                                m_eActiveModel = m_eMainBoardModel;
                            }
                            m_eMode = objConfiguration.eMode;

                            MinFreqMHZ = objConfiguration.fMinFreqMHZ;
                            MaxFreqMHZ = objConfiguration.fMaxFreqMHZ;
                            MaxSpanMHZ = objConfiguration.fMaxSpanMHZ;

                            m_fRBWKHZ = objConfiguration.fRBWKHZ;
                            m_fOffset_dB = objConfiguration.fOffset_dB;

                            if ((m_eActiveModel == eModel.MODEL_2400) || (m_eActiveModel == eModel.MODEL_6G))
                            {
                                MinSpanMHZ = 2.0;
                            }
                            else
                            {
                                MinSpanMHZ = 0.112;
                            }

                            if (objConfiguration.nFreqSpectrumSteps == 13)
                            {
                                m_eMode = RFECommunicator.eMode.MODE_WIFI_ANALYZER;
                            }
                            else
                            {
                                m_eMode = RFECommunicator.eMode.MODE_SPECTRUM_ANALYZER;
                            }

                            OnReceivedConfigurationData(new EventArgs());
                        }
                    }
                    else if (objNew.GetType() == typeof(RFESweepData))
                    {
                        if (m_eMode == eMode.MODE_TRACKING)
                        {
                            if (m_bTrackingNormalizing)
                            {
                                if (m_SweepTrackingNormalizedContainer == null)
                                    m_SweepTrackingNormalizedContainer = new RFESweepDataCollection(3,true);

                                RFESweepData objSweep=(RFESweepData)objNew;
                                m_SweepTrackingNormalizedContainer.Add(objSweep);
                                bool bWrongData=objSweep.GetAmplitudeDBM(objSweep.GetMinStep())<=MIN_AMPLITUDE_TRACKING_NORMALIZE;

                                if (bWrongData || ((m_nAutoStopSNATrackingCounter != 0) && (m_SweepTrackingNormalizedContainer.Count >= m_nAutoStopSNATrackingCounter)))
                                {
                                    StopTracking();

                                    if (bWrongData)
                                        //invalid data, end so it can be restarted
                                        m_SweepTrackingNormalized = objSweep;
                                    else
                                        //if all samples collected, end and get average among them
                                        m_SweepTrackingNormalized = m_SweepTrackingNormalizedContainer.GetAverage(0, m_SweepTrackingNormalizedContainer.Count - 1);

                                    OnUpdateDataTrakingNormalization(new EventArgs());
                                }
                            }
                            else
                            {
                                RFESweepData objSweep = (RFESweepData)objNew;
                                m_TrackingDataContainer.Add(objSweep);
                                bDraw = true;
                                OnUpdateDataTraking(new EventArgs());

                                if ((m_nAutoStopSNATrackingCounter != 0) && (m_nTrackingPass > m_nAutoStopSNATrackingCounter))
                                {
                                    StopTracking();
                                }
                            }
                        }
                        else
                        {
                            if (!HoldMode)
                            {
                                RFESweepData objSweep = (RFESweepData)objNew;
                                m_SweepDataContainer.Add(objSweep);

                                bDraw = true;
                                if (m_SweepDataContainer.IsFull())
                                {
                                    HoldMode = true;
                                    OnUpdateFeedMode(new EventArgs());
                                    ReportLog("RAM Buffer is full.");
                                }
                                m_sSweepInfoText = "Captured:" + objSweep.CaptureTime.ToString("yyyy-MM-dd HH:mm:ss\\.fff");
                                TimeSpan objSpan = new TimeSpan();
                                objSpan = objSweep.CaptureTime - m_LastCaptureTime;
                                if (objSpan.TotalSeconds < 60)
                                {
                                    //if time between captures is less than 60 seconds, we can assume we are getting realtime data
                                    //and therefore can provide average sweep/seconds information, otherwise we were in hold or something
                                    //and data could not be used for these calculations.
                                    m_nAverageSweepSpeedIterator++;
                                    m_spanAverageSpeedAcumulator += (objSweep.CaptureTime - m_LastCaptureTime);
                                    if (m_fAverageSweepTime > 0.0)
                                    {
                                        m_sSweepInfoText += "\nSweep time: " + m_fAverageSweepTime.ToString("0.000") + " seconds - Avg Sweeps/second: " + (1.0 / m_fAverageSweepTime).ToString("0.0");
                                    }
                                    if (m_nAverageSweepSpeedIterator >= 10)
                                    {
                                        m_fAverageSweepTime = m_spanAverageSpeedAcumulator.TotalSeconds / m_nAverageSweepSpeedIterator;
                                        m_nAverageSweepSpeedIterator = 0;
                                        m_spanAverageSpeedAcumulator = m_LastCaptureTime - m_LastCaptureTime; //set it to zero and start average all over again
                                    }
                                }
                                m_LastCaptureTime = objSweep.CaptureTime;

                                OnUpdateData(new EventArgs());
                            }
                            else
                            {
                                //if in hold mode, we just record last time came here to make sure we start from most reliable point in time
                                m_LastCaptureTime = DateTime.Now;
                            }
                        }
                    }
                    else if (objNew.GetType() == typeof(RFEScreenData))
                    {
                        if ((CaptureRemoteScreen) && (m_ScreenDataContainer.IsFull() == false))
                        {
                            RFEScreenData objScreen = (RFEScreenData)objNew;
                            objScreen.Model = ActiveModel;
                            m_ScreenDataContainer.Add(objScreen);
                            ScreenIndex = (UInt16)m_ScreenDataContainer.UpperBound;
                            OnUpdateRemoteScreen(new EventArgs());
                        }
                        else
                        {
                            //receiving Screen Dump data but it was intended to be disabled, resend a disable command now
                            SendCommand("D0");
                        }
                    }
                    else
                    {
                        //received a string, so use it along to parse parameters
                        string sLine = (string)objNew;
                        sReceivedString = sLine;

                        if ((sLine.Length > 3) && (sLine.Substring(0, 4) == _Acknowldedge))
                        {
                            m_bAcknowledge = true;
                        }
                        else if ((sLine.Length > 16) && (sLine.Substring(0, 3) == "#Sn"))
                        {
                            m_sSerialNumber = sLine.Substring(3, 16);
                            ReportLog("Device serial number: " + SerialNumber);
                        }
                        else if((sLine.Length > 2) && (sLine.Substring(0, 2) == "$q"))
                        {
                            //calibration data
                            UInt16 nSize=Convert.ToUInt16(sLine[2]);

                            if (IsGenerator())
                            {
                                //signal generator uses a different approach for storing absolute amplitude value offset over an ideal -30dBm response
                                if ((m_arrSignalGeneratorEmbeddedCalibrationActual30DBM == null) || (m_arrSignalGeneratorEmbeddedCalibrationActual30DBM.Length != nSize))
                                {
                                    m_arrSignalGeneratorEmbeddedCalibrationActual30DBM = new double[nSize];
                                    for (int nInd = 0; nInd < nSize; nInd++)
                                    {
                                        m_arrSignalGeneratorEmbeddedCalibrationActual30DBM[nInd] = -30.0;
                                    }

                                    //Values using 10*delta from the value delivered when compared with 30dBm.
                                    //For instance if value delivered for a frequency is -28.5dBm, that is a +1.5dB difference
                                    //therefore a 1.5*10=15 value. If the value delivered is -33.2 that is a -3.2dB difference
                                    //therefore a -32 value.

                                    string sData = "Embedded calibration Signal Generator data received:";
                                    for (int nInd = 0; nInd < nSize; nInd++)
                                    {
                                        m_arrSignalGeneratorEmbeddedCalibrationActual30DBM[nInd] = -30.0 + Convert.ToInt16(sLine[nInd + 3]) / 10.0;
                                        sData += m_arrSignalGeneratorEmbeddedCalibrationActual30DBM[nInd].ToString();
                                        if (nInd < nSize - 1)
                                            sData += ",";
                                    }
                                    ReportLog(sData);
                                }
                            }
                            else
                            {
                                if ((m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB == null) || (m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB.Length != nSize))
                                {
                                    m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB = new float[nSize];
                                    for (int nInd = 0; nInd < nSize; nInd++)
                                    {
                                        m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB[nInd] = 0.0f;
                                    }
                                }

                                if (m_eActiveModel == eModel.MODEL_6G)
                                {
                                    string sData = "Embedded calibration Spectrum Analyzer data received:";
                                    for (int nInd = POS_EMBEDDED_CALIBRATED_6G; nInd < nSize; nInd++)
                                    {
                                        int nVal = Convert.ToInt32(sLine[nInd + 3]);
                                        if (nVal > 127)
                                            nVal = -(256 - nVal); //get the right sign
                                        m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB[nInd] = nVal / 2.0f; //split by two to get dB
                                        sData += m_arrSpectrumAnalyzerEmbeddedCalibrationOffsetDB[nInd].ToString();
                                        if (nInd < nSize - 1)
                                            sData += ",";
                                    }
                                    ReportLog(sData);
                                }
                            }
                        }
                        else if ((sLine.Length > 18) && (sLine.Substring(0, 18) == _ResetString))
                        {
                            //RF Explorer device was reset for some reason, reconfigure client based on new configuration
                            OnDeviceResetEvent(new EventArgs());
                        }
                        else if ((sLine.Length > 5) && sLine.Substring(0, 6) == "#C2-M:")
                        {
                            ReportLog("Received RF Explorer device model info:" + sLine);
                            m_eMainBoardModel = (eModel)Convert.ToUInt16(sLine.Substring(6, 3));
                            m_eExpansionBoardModel = (eModel)Convert.ToUInt16(sLine.Substring(10, 3));
                            m_sRFExplorerFirmware = (sLine.Substring(14, 5));
                            OnReceivedDeviceModel(new EventArgs());
                        }
                        else if ((sLine.Length > 5) && sLine.Substring(0, 6) == "#C3-M:")
                        {
                            ReportLog("Received RF Explorer Generator device info:" + sLine);
                            m_eMainBoardModel = (eModel)Convert.ToUInt16(sLine.Substring(6, 3));
                            m_eExpansionBoardModel = (eModel)Convert.ToUInt16(sLine.Substring(10, 3));
                            m_sRFExplorerFirmware = (sLine.Substring(14, 5));
                            OnReceivedDeviceModel(new EventArgs());
                        }
                        else if ((sLine.Length > 2) && sLine.Substring(0, 3) == "#K1")
                        {
                            ReportLog("RF Explorer is now in TRACKING mode.");
                            m_eMode = eMode.MODE_TRACKING;
                        }
                        else if ((sLine.Length > 2) && sLine.Substring(0, 3) == "#K0")
                        {
                            ReportLog("RF Explorer is now in ANALYZER mode.");
                            m_eMode = eMode.MODE_SPECTRUM_ANALYZER;
                        }
                        else if ((sLine.Length > 2) && (sLine.Substring(0, 2) == "$S") && (StartFrequencyMHZ > 0.1))
                        {
                            bWrongFormat = true;
                        }
#if SUPPORT_EXPERIMENTAL
                    else if ((sLine.Length > 2) && sLine.Substring(0, 2) == "$R")
                    {
                        if (!HoldMode && m_nRAWSnifferIndex < m_nTotalBufferSize)
                        {
                            if (m_arrRAWSnifferData == null)
                            {
                                //don't allocate memory for this object before actually required as most users may not need this
                                m_arrRAWSnifferData = new string[m_nTotalBufferSize];
                            }
                            m_nRAWSnifferIndex++;
                            if (m_nRAWSnifferIndex >= m_nTotalBufferSize)
                            {
                                m_nRAWSnifferIndex = m_nTotalBufferSize;
                                HoldMode = true;
                                UpdateFeedMode();
                                ReportLog("Buffer is full.");
                            }
                            else
                            {
                                m_arrRAWSnifferData[m_nRAWSnifferIndex] = sLine;
                            }
                            m_nMaxRAWSnifferIndex = m_nRAWSnifferIndex;
                            DrawRAWDecoder();
                        }
                    }
#endif
                        else if ((sLine.Length > 5) && (sLine.Substring(0, 6) == "#C2-F:"))
                        {
                            bWrongFormat = true; //parsed on the thread
                        }
                        else if ((sLine.Length > 5) && (sLine.Substring(0, 6) == "#C1-F:"))
                        {
                            bWrongFormat = true; //obsolete firmware
                        }
                        else
                        {
                            ReportLog(sLine); //report any line we don't understand - it is likely a human readable message
                        }

                        if (bWrongFormat)
                        {
                            ReportLog("Received unexpected data from RFExplorer device:" + sLine);
                            ReportLog("Please update your RF Explorer to a recent firmware version and");
                            ReportLog("make sure you are using the latest version of RF Explorer for Windows.");
                            ReportLog("Visit http://www.rf-explorer/download for latest firmware updates.");

                            OnWrongFormatData(new EventArgs());
                        }
                    }

                } while (bProcessAllEvents && (m_arrReceivedData.Count > 0));
            }
            catch (Exception obEx)
            {
                ReportLog("ProcessReceivedString: " + sReceivedString + Environment.NewLine + obEx.ToString());
            }

            return bDraw;
        }